@algocare/react-native-code-push 12.6.2 → 12.6.3

package/CodePush.js

@@ -586,6 +586,9 @@ async function syncInternal(
                 }
               }
               break
+            case CodePush.SyncStatus.PREPARING_UPDATE:
+              log('Download complete. Preparing update (unzip/file-copy).')
+              break
             case CodePush.SyncStatus.UNKNOWN_ERROR:
               log('An unknown error occurred.')
               break
@@ -608,7 +611,11 @@ async function syncInternal(
     const doDownloadAndInstall = async () => {
       syncStatusChangeCallback(CodePush.SyncStatus.DOWNLOADING_PACKAGE)
       const localPackage = await remotePackage.download(
-        downloadProgressCallback
+        downloadProgressCallback,
+        () => {
+          // HTTP download complete, post-processing (unzip/file-copy) starts
+          syncStatusChangeCallback(CodePush.SyncStatus.PREPARING_UPDATE)
+        }
       )
 
       // Determine the correct install mode based on whether the update is mandatory or not.
@@ -924,6 +931,7 @@ if (NativeCodePush) {
       AWAITING_USER_ACTION: 6,
       DOWNLOADING_PACKAGE: 7,
       INSTALLING_UPDATE: 8,
+      PREPARING_UPDATE: 9, // HTTP download complete, post-processing (unzip/file-copy) in progress
     },
     CheckFrequency: {
       ON_APP_START: 0,

package/ios/CodePush/CodePush.h

@@ -108,9 +108,9 @@
 
 @end
 
-@interface CodePushDownloadHandler : NSObject <NSURLConnectionDelegate>
+@interface CodePushDownloadHandler : NSObject <NSURLSessionDownloadDelegate>
 
-@property (strong) NSOutputStream *outputFileStream;
+@property (strong) NSString *downloadFilePath;
 @property long long expectedContentLength;
 @property long long receivedContentLength;
 @property dispatch_queue_t operationQueue;
@@ -144,7 +144,9 @@ failCallback:(void (^)(NSError *err))failCallback;
          operationQueue:(dispatch_queue_t)operationQueue
        progressCallback:(void (^)(long long, long long))progressCallback
            doneCallback:(void (^)())doneCallback
-           failCallback:(void (^)(NSError *err))failCallback;
+           failCallback:(void (^)(NSError *err))failCallback
+installProgressCallback:(void (^)(NSString *, NSNumber *, NSNumber *))installProgressCallback
+downloadCompleteCallback:(void (^)())downloadCompleteCallback;
 
 + (NSDictionary *)getCurrentPackage:(NSError **)error;
 + (NSDictionary *)getPreviousPackage:(NSError **)error;

package/ios/CodePush/CodePush.m

@@ -43,6 +43,8 @@ RCT_EXPORT_MODULE()
 
 // These constants represent emitted events
 static NSString *const DownloadProgressEvent = @"CodePushDownloadProgress";
+static NSString *const DownloadCompleteEvent = @"CodePushDownloadComplete";
+static NSString *const InstallProgressEvent = @"CodePushInstallProgress";
 
 // These constants represent valid deployment statuses
 static NSString *const DeploymentFailed = @"DeploymentFailed";
@@ -640,7 +642,7 @@ static NSString *const LatestRollbackCountKey = @"count";
 }
 
 - (NSArray<NSString *> *)supportedEvents {
-    return @[DownloadProgressEvent];
+    return @[DownloadProgressEvent, DownloadCompleteEvent, InstallProgressEvent];
 }
 
 // Determine how long the app was in the background
@@ -726,6 +728,17 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
 
     NSString * publicKey = [[CodePushConfig current] publicKey];
 
+    // Install progress callback for reporting unzip/file-copy progress to JS
+    void (^installProgressCallback)(NSString *, NSNumber *, NSNumber *) =
+        ^(NSString *phase, NSNumber *current, NSNumber *total) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self sendEventWithName:InstallProgressEvent
+                                   body:@{@"phase": phase,
+                                          @"current": current,
+                                          @"total": total}];
+            });
+        };
+
     [CodePushPackage
         downloadPackage:mutableUpdatePackage
         expectedBundleFileName:[bundleResourceName stringByAppendingPathExtension:bundleResourceExtension]
@@ -746,7 +759,7 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
                 [self dispatchDownloadProgressEvent];
             }
         }
-        // The download completed
+        // The download and post-processing completed
         doneCallback:^{
             NSError *err;
             NSDictionary *newPackage = [CodePushPackage getPackage:mutableUpdatePackage[PackageHashKey] error:&err];
@@ -766,6 +779,14 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
             _didUpdateProgress = NO;
             self.paused = YES;
             reject([NSString stringWithFormat: @"%lu", (long)err.code], err.localizedDescription, err);
+        }
+        // Install progress (unzip/file-copy) callback
+        installProgressCallback:installProgressCallback
+        // Notify JS that HTTP download is complete and post-processing begins
+        downloadCompleteCallback:^{
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self sendEventWithName:DownloadCompleteEvent body:@{}];
+            });
         }];
 }
 

package/ios/CodePush/CodePushDownloadHandler.m

@@ -1,8 +1,10 @@
 #import "CodePush.h"
 
+static const NSTimeInterval kDownloadTimeoutInterval = 60.0;
+
 @implementation CodePushDownloadHandler {
-    // Header chars used to determine if the file is a zip.
-    char _header[4];
+    NSURLSession *_session;
+    BOOL _completed; // 콜백 중복 호출 방지 플래그
 }
 
 - (id)init:(NSString *)downloadFilePath
@@ -10,121 +12,141 @@ operationQueue:(dispatch_queue_t)operationQueue
 progressCallback:(void (^)(long long, long long))progressCallback
 doneCallback:(void (^)(BOOL))doneCallback
 failCallback:(void (^)(NSError *err))failCallback {
-    self.outputFileStream = [NSOutputStream outputStreamToFileAtPath:downloadFilePath
-                                                              append:NO];
-    self.receivedContentLength = 0;
-    self.operationQueue = operationQueue;
-    self.progressCallback = progressCallback;
-    self.doneCallback = doneCallback;
-    self.failCallback = failCallback;
+    self = [super init];
+    if (self) {
+        self.downloadFilePath = downloadFilePath;
+        self.receivedContentLength = 0;
+        self.expectedContentLength = 0;
+        self.operationQueue = operationQueue;
+        self.progressCallback = progressCallback;
+        self.doneCallback = doneCallback;
+        self.failCallback = failCallback;
+        _completed = NO;
+    }
     return self;
 }
 
 - (void)download:(NSString *)url {
     self.downloadUrl = url;
+    NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
+    config.timeoutIntervalForRequest = kDownloadTimeoutInterval;
+
+    NSOperationQueue *delegateQueue = [NSOperationQueue new];
+    delegateQueue.underlyingQueue = self.operationQueue;
+
+    _session = [NSURLSession sessionWithConfiguration:config
+                                             delegate:self
+                                        delegateQueue:delegateQueue];
+
     NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:url]
                                              cachePolicy:NSURLRequestUseProtocolCachePolicy
-                                         timeoutInterval:60.0];
-    NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:request
-                                                                  delegate:self
-                                                          startImmediately:NO];
-    if ([NSOperationQueue instancesRespondToSelector:@selector(setUnderlyingQueue:)]) {
-        NSOperationQueue *delegateQueue = [NSOperationQueue new];
-        delegateQueue.underlyingQueue = self.operationQueue;
-        [connection setDelegateQueue:delegateQueue];
-    } else {
-        [connection scheduleInRunLoop:[NSRunLoop mainRunLoop]
-                              forMode:NSDefaultRunLoopMode];
-    }
+                                         timeoutInterval:kDownloadTimeoutInterval];
+    NSURLSessionDownloadTask *task = [_session downloadTaskWithRequest:request];
+    [task resume];
+}
 
-    [connection start];
+- (void)invokeFailCallback:(NSError *)error {
+    if (_completed) return;
+    _completed = YES;
+    if (self.failCallback) {
+        self.failCallback(error);
+    }
 }
 
-#pragma mark NSURLConnection Delegate Methods
+- (void)invokeDoneCallback:(BOOL)isZip {
+    if (_completed) return;
+    _completed = YES;
+    if (self.doneCallback) {
+        self.doneCallback(isZip);
+    }
+}
 
-- (NSCachedURLResponse *)connection:(NSURLConnection *)connection
-                  willCacheResponse:(NSCachedURLResponse*)cachedResponse {
-    // Return nil to indicate not necessary to store a cached response for this connection
-    return nil;
+#pragma mark - NSURLSessionDownloadDelegate
+
+- (void)URLSession:(NSURLSession *)session
+      downloadTask:(NSURLSessionDownloadTask *)downloadTask
+      didWriteData:(int64_t)bytesWritten
+ totalBytesWritten:(int64_t)totalBytesWritten
+totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite {
+    self.expectedContentLength = totalBytesExpectedToWrite;
+    self.receivedContentLength = totalBytesWritten;
+    if (self.progressCallback) {
+        self.progressCallback(self.expectedContentLength, self.receivedContentLength);
+    }
 }
 
-- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response {
-    if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
-        NSInteger statusCode = [(NSHTTPURLResponse *)response statusCode];
+- (void)URLSession:(NSURLSession *)session
+      downloadTask:(NSURLSessionDownloadTask *)downloadTask
+didFinishDownloadingToURL:(NSURL *)location {
+    // Check HTTP status code
+    if ([downloadTask.response isKindOfClass:[NSHTTPURLResponse class]]) {
+        NSInteger statusCode = ((NSHTTPURLResponse *)downloadTask.response).statusCode;
         if (statusCode >= 400) {
-            [self.outputFileStream close];
-            [connection cancel];
-            NSError *err = [CodePushErrorUtils errorWithMessage:[NSString stringWithFormat: @"Received %ld response from %@", (long)statusCode, self.downloadUrl]];
-            self.failCallback(err);
+            NSError *err = [CodePushErrorUtils errorWithMessage:
+                            [NSString stringWithFormat:@"Received %ld response from %@",
+                             (long)statusCode, self.downloadUrl]];
+            [self invokeFailCallback:err];
             return;
         }
     }
-    
-    self.expectedContentLength = response.expectedContentLength;
-    [self.outputFileStream open];
-}
 
-- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data {
-    if (self.receivedContentLength < 4) {
-        for (int i = 0; i < [data length]; i++) {
-            int headerOffset = (int)self.receivedContentLength + i;
-            if (headerOffset >= 4) {
-                break;
-            }
+    // Move downloaded file from temporary location to our target path
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSError *moveError = nil;
 
-            const char *bytes = [data bytes];
-            _header[headerOffset] = bytes[i];
-        }
+    // Remove existing file if present
+    if ([fileManager fileExistsAtPath:self.downloadFilePath]) {
+        [fileManager removeItemAtPath:self.downloadFilePath error:nil];
     }
 
-    self.receivedContentLength = self.receivedContentLength + [data length];
-
-    NSInteger bytesLeft = [data length];
+    [fileManager moveItemAtURL:location
+                         toURL:[NSURL fileURLWithPath:self.downloadFilePath]
+                         error:&moveError];
 
-    do {
-        NSInteger bytesWritten = [self.outputFileStream write:[data bytes]
-                                                     maxLength:bytesLeft];
-        if (bytesWritten == -1) {
-            break;
-        }
-
-        bytesLeft -= bytesWritten;
-    } while (bytesLeft > 0);
+    if (moveError) {
+        [self invokeFailCallback:moveError];
+        return;
+    }
 
-    self.progressCallback(self.expectedContentLength, self.receivedContentLength);
+    if (self.receivedContentLength < 1) {
+        NSError *err = [CodePushErrorUtils errorWithMessage:
+                        [NSString stringWithFormat:@"Received empty response from %@",
+                         self.downloadUrl]];
+        [self invokeFailCallback:err];
+        return;
+    }
 
-    // bytesLeft should not be negative.
-    assert(bytesLeft >= 0);
+    // Determine if the downloaded file is a ZIP by reading its header
+    BOOL isZip = NO;
+    NSFileHandle *fileHandle = [NSFileHandle fileHandleForReadingAtPath:self.downloadFilePath];
+    if (fileHandle) {
+        NSData *headerData = [fileHandle readDataOfLength:4];
+        [fileHandle closeFile];
+        if (headerData.length >= 4) {
+            const char *bytes = [headerData bytes];
+            isZip = bytes[0] == 'P' && bytes[1] == 'K' && bytes[2] == 3 && bytes[3] == 4;
+        }
+    }
 
-    if (bytesLeft) {
-        [self.outputFileStream close];
-        [connection cancel];
-        self.failCallback([self.outputFileStream streamError]);
+    // Send final 100% progress callback
+    // Use receivedContentLength for both args to guarantee expected == received at completion
+    if (self.progressCallback) {
+        self.progressCallback(self.receivedContentLength, self.receivedContentLength);
     }
-}
 
-- (void)connection:(NSURLConnection*)connection didFailWithError:(NSError*)error
-{
-    [self.outputFileStream close];
-    self.failCallback(error);
+    [self invokeDoneCallback:isZip];
 }
 
-- (void)connectionDidFinishLoading:(NSURLConnection *)connection {
-    [self.outputFileStream close];
-    if (self.receivedContentLength < 1) {
-        NSError *err = [CodePushErrorUtils errorWithMessage:[NSString stringWithFormat:@"Received empty response from %@", self.downloadUrl]];
-        self.failCallback(err);
-        return;
-    }
-    
-    // expectedContentLength might be -1 when NSURLConnection don't know the length(e.g. response encode with gzip)
-    if (self.expectedContentLength > 0) {
-        // We should have received all of the bytes if this is called.
-        assert(self.receivedContentLength == self.expectedContentLength);
-    }
+#pragma mark - NSURLSessionTaskDelegate
 
-    BOOL isZip = _header[0] == 'P' && _header[1] == 'K' && _header[2] == 3 && _header[3] == 4;
-    self.doneCallback(isZip);
+- (void)URLSession:(NSURLSession *)session
+              task:(NSURLSessionTask *)task
+didCompleteWithError:(NSError *)error {
+    if (error) {
+        [self invokeFailCallback:error];
+    }
+    [session finishTasksAndInvalidate];
+    _session = nil; // Break retain cycle (NSURLSession strong-references its delegate)
 }
 
 @end

package/ios/CodePush/CodePushPackage.m

@@ -50,6 +50,8 @@ static NSString *const UnzippedFolderName = @"unzipped";
        progressCallback:(void (^)(long long, long long))progressCallback
            doneCallback:(void (^)())doneCallback
            failCallback:(void (^)(NSError *err))failCallback
+installProgressCallback:(void (^)(NSString *, NSNumber *, NSNumber *))installProgressCallback
+downloadCompleteCallback:(void (^)())downloadCompleteCallback
 {
     NSString *newUpdateHash = updatePackage[@"packageHash"];
     NSString *newUpdateFolderPath = [self getPackageFolderPath:newUpdateHash];
@@ -85,6 +87,11 @@ static NSString *const UnzippedFolderName = @"unzipped";
                                                 operationQueue:operationQueue
                                                 progressCallback:progressCallback
                                                 doneCallback:^(BOOL isZip) {
+                                                    // HTTP 다운로드 완료 → 후처리(unzip/파일복사) 시작 전 알림
+                                                    if (downloadCompleteCallback) {
+                                                        downloadCompleteCallback();
+                                                    }
+
                                                     NSError *error = nil;
                                                     NSString * unzippedFolderPath = [CodePushPackage getUnzippedFolderPath];
                                                     NSMutableDictionary * mutableUpdatePackage = [updatePackage mutableCopy];
@@ -101,8 +108,21 @@ static NSString *const UnzippedFolderName = @"unzipped";
                                                         }
                                                         
                                                         NSError *nonFailingError = nil;
-                                                        [SSZipArchive unzipFileAtPath:downloadFilePath
-                                                                        toDestination:unzippedFolderPath];
+                                                        BOOL unzipSuccess = [SSZipArchive unzipFileAtPath:downloadFilePath
+                                                                        toDestination:unzippedFolderPath
+                                                                            overwrite:YES
+                                                                             password:nil
+                                                                      progressHandler:^(NSString *entry, unz_file_info zipInfo, long entryNumber, long total) {
+                                                                          if (installProgressCallback && total > 0) {
+                                                                              installProgressCallback(@"EXTRACTING", @(entryNumber), @(total));
+                                                                          }
+                                                                      }
+                                                                    completionHandler:nil];
+                                                        if (!unzipSuccess) {
+                                                            error = [CodePushErrorUtils errorWithMessage:@"Failed to unzip the downloaded update."];
+                                                            failCallback(error);
+                                                            return;
+                                                        }
                                                         [[NSFileManager defaultManager] removeItemAtPath:downloadFilePath
                                                                                                    error:&nonFailingError];
                                                         if (nonFailingError) {

package/package-mixins.js

@@ -7,19 +7,31 @@ import log from "./logging";
 module.exports = (NativeCodePush) => {
   const remote = () => {
     return {
-      async download(downloadProgressCallback) {
+      async download(downloadProgressCallback, downloadCompleteCallback) {
         if (!this.downloadUrl) {
           throw new Error("Cannot download an update without a download url");
         }
 
         let downloadProgressSubscription;
-        if (downloadProgressCallback) {
+        let downloadCompleteSubscription;
+        if (downloadProgressCallback || downloadCompleteCallback) {
           const codePushEventEmitter = new NativeEventEmitter(NativeCodePush);
-          // Use event subscription to obtain download progress.
-          downloadProgressSubscription = codePushEventEmitter.addListener(
-            "CodePushDownloadProgress",
-            downloadProgressCallback
-          );
+
+          if (downloadProgressCallback) {
+            // Use event subscription to obtain download progress.
+            downloadProgressSubscription = codePushEventEmitter.addListener(
+              "CodePushDownloadProgress",
+              downloadProgressCallback
+            );
+          }
+
+          if (downloadCompleteCallback) {
+            // Listen for download complete event (HTTP download done, post-processing starts)
+            downloadCompleteSubscription = codePushEventEmitter.addListener(
+              "CodePushDownloadComplete",
+              downloadCompleteCallback
+            );
+          }
         }
 
         // Use the downloaded package info. Native code will save the package info
@@ -33,6 +45,7 @@ module.exports = (NativeCodePush) => {
           return { ...downloadedPackage, ...local };
         } finally {
           downloadProgressSubscription && downloadProgressSubscription.remove();
+          downloadCompleteSubscription && downloadCompleteSubscription.remove();
         }
       },
 
@@ -58,4 +71,4 @@ module.exports = (NativeCodePush) => {
   };
 
   return { local, remote };
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algocare/react-native-code-push",
-  "version": "12.6.2",
+  "version": "12.6.3",
   "description": "React Native plugin for the CodePush service",
   "main": "CodePush.js",
   "typings": "typings/react-native-code-push.d.ts",

package/typings/react-native-code-push.d.ts

@@ -167,9 +167,11 @@ export interface RemotePackage extends Package {
    * Downloads the available update from the CodePush service.
    *
    * @param downloadProgressCallback An optional callback that allows tracking the progress of the update while it is being downloaded.
+   * @param downloadCompleteCallback An optional callback that is called when the HTTP download completes and post-processing begins (iOS only).
    */
   download(
-    downloadProgressCallback?: DownloadProgressCallback
+    downloadProgressCallback?: DownloadProgressCallback,
+    downloadCompleteCallback?: () => void
   ): Promise<LocalPackage>
 
   /**
@@ -490,6 +492,12 @@ declare namespace CodePush {
      * An available update was downloaded and is about to be installed.
      */
     INSTALLING_UPDATE,
+
+    /**
+     * The update has been downloaded and post-processing (unzip/file copy) is in progress.
+     * This status is only reported on iOS when the native module supports it.
+     */
+    PREPARING_UPDATE,
   }
 
   /**