@capgo/capacitor-updater 6.1.2 → 6.1.4

package/android/src/main/java/ee/forgr/capacitor_updater/CapacitorUpdaterPlugin.java

@@ -56,7 +56,7 @@ public class CapacitorUpdaterPlugin extends Plugin {
   private static final String channelUrlDefault =
     "https://api.capgo.app/channel_self";
 
-  private final String PLUGIN_VERSION = "6.1.2";
+  private final String PLUGIN_VERSION = "6.1.4";
   private static final String DELAY_CONDITION_PREFERENCES = "";
 
   private SharedPreferences.Editor editor;

package/android/src/main/java/ee/forgr/capacitor_updater/DownloadService.java

@@ -3,17 +3,15 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
-
 package ee.forgr.capacitor_updater;
 
 import android.app.IntentService;
 import android.content.Intent;
-import java.io.DataInputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.InputStream;
+import java.io.*;
+import java.net.HttpURLConnection;
 import java.net.URL;
 import java.net.URLConnection;
+import java.nio.channels.FileChannel;
 import java.util.Objects;
 
 public class DownloadService extends IntentService {
@@ -30,20 +28,22 @@ public class DownloadService extends IntentService {
   public static final String SIGNATURE = "signature";
   public static final String NOTIFICATION = "service receiver";
   public static final String PERCENTDOWNLOAD = "percent receiver";
+  private static final String UPDATE_FILE = "update.dat";
 
   public DownloadService() {
     super("Background DownloadService");
   }
 
-  private int calcTotalPercent(
-    final int percent,
-    final int min,
-    final int max
-  ) {
-    return (percent * (max - min)) / 100 + min;
+  private int calcTotalPercent(long downloadedBytes, long contentLength) {
+    if (contentLength <= 0) {
+      return 0;
+    }
+    int percent = (int) (((double) downloadedBytes / contentLength) * 100);
+    percent = Math.max(10, percent);
+    percent = Math.min(70, percent);
+    return percent;
   }
 
-  // Will be called asynchronously by OS.
   @Override
   protected void onHandleIntent(Intent intent) {
     assert intent != null;
@@ -56,47 +56,95 @@ public class DownloadService extends IntentService {
     String checksum = intent.getStringExtra(CHECKSUM);
     String signature = intent.getStringExtra(SIGNATURE);
 
+    File target = new File(documentsDir, dest);
+    File infoFile = new File(documentsDir, UPDATE_FILE); // The file where the download progress (how much byte
+    // downloaded) is stored
+    File tempFile = new File(documentsDir, "temp" + ".tmp"); // Temp file, where the downloaded data is stored
     try {
-      final URL u = new URL(url);
-      final URLConnection connection = u.openConnection();
+      URL u = new URL(url);
+      HttpURLConnection httpConn = (HttpURLConnection) u.openConnection();
+
+      // Reading progress file (if exist)
+      long downloadedBytes = 0;
+
+      if (infoFile.exists() && tempFile.exists()) {
+        try (
+          BufferedReader reader = new BufferedReader(new FileReader(infoFile))
+        ) {
+          String updateVersion = reader.readLine();
+          if (!updateVersion.equals(version)) {
+            clearDownloadData(documentsDir);
+            downloadedBytes = 0;
+          } else {
+            downloadedBytes = tempFile.length();
+          }
+        }
+      } else {
+        clearDownloadData(documentsDir);
+        downloadedBytes = 0;
+      }
+
+      if (downloadedBytes > 0) {
+        httpConn.setRequestProperty("Range", "bytes=" + downloadedBytes + "-");
+      }
+
+      int responseCode = httpConn.getResponseCode();
 
-      try (
-        final InputStream is = u.openStream();
-        final DataInputStream dis = new DataInputStream(is)
+      if (
+        responseCode == HttpURLConnection.HTTP_OK ||
+        responseCode == HttpURLConnection.HTTP_PARTIAL
       ) {
-        assert dest != null;
-        final File target = new File(documentsDir, dest);
-        Objects.requireNonNull(target.getParentFile()).mkdirs();
-        target.createNewFile();
-        try (final FileOutputStream fos = new FileOutputStream(target)) {
-          final long totalLength = connection.getContentLength();
-          final int bufferSize = 1024;
-          final byte[] buffer = new byte[bufferSize];
-          int length;
-
-          int bytesRead = bufferSize;
-          int percent = 0;
-          this.notifyDownload(id, 10);
-          while ((length = dis.read(buffer)) > 0) {
-            fos.write(buffer, 0, length);
-            final int newPercent = (int) ((bytesRead * 100) / totalLength);
-            if (totalLength > 1 && newPercent != percent) {
-              percent = newPercent;
-              this.notifyDownload(id, this.calcTotalPercent(percent, 10, 70));
-            }
-            bytesRead += length;
+        String contentType = httpConn.getContentType();
+        long contentLength = httpConn.getContentLength() + downloadedBytes;
+
+        InputStream inputStream = httpConn.getInputStream();
+        FileOutputStream outputStream = new FileOutputStream(
+          tempFile,
+          downloadedBytes > 0
+        );
+        if (downloadedBytes == 0) {
+          try (
+            BufferedWriter writer = new BufferedWriter(new FileWriter(infoFile))
+          ) {
+            writer.write(String.valueOf(version));
           }
-          publishResults(
-            dest,
-            id,
-            version,
-            checksum,
-            sessionKey,
-            signature,
-            ""
-          );
         }
+        // Updating the info file
+        try (
+          BufferedWriter writer = new BufferedWriter(new FileWriter(infoFile))
+        ) {
+          writer.write(String.valueOf(version));
+        }
+
+        int bytesRead = -1;
+        byte[] buffer = new byte[4096];
+        int lastPercent = 0;
+        while ((bytesRead = inputStream.read(buffer)) != -1) {
+          outputStream.write(buffer, 0, bytesRead);
+          downloadedBytes += bytesRead;
+          // Saving progress (flushing every 100 Ko)
+          if (downloadedBytes % 102400 == 0) {
+            outputStream.flush();
+          }
+          // Computing percentage
+          int percent = calcTotalPercent(downloadedBytes, contentLength);
+          if (percent != lastPercent) {
+            notifyDownload(id, percent);
+            lastPercent = percent;
+          }
+        }
+
+        outputStream.close();
+        inputStream.close();
+
+        // Rename the temp file with the final name (dest)
+        tempFile.renameTo(new File(documentsDir, dest));
+        infoFile.delete();
+        publishResults(dest, id, version, checksum, sessionKey, signature, "");
+      } else {
+        infoFile.delete();
       }
+      httpConn.disconnect();
     } catch (OutOfMemoryError e) {
       e.printStackTrace();
       publishResults(
@@ -122,6 +170,19 @@ public class DownloadService extends IntentService {
     }
   }
 
+  private void clearDownloadData(String docDir) {
+    File tempFile = new File(docDir, "temp" + ".tmp");
+    File infoFile = new File(docDir, UPDATE_FILE);
+    try {
+      tempFile.delete();
+      infoFile.delete();
+      infoFile.createNewFile();
+      tempFile.createNewFile();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
   private void notifyDownload(String id, int percent) {
     Intent intent = new Intent(PERCENTDOWNLOAD);
     intent.setPackage(getPackageName());
@@ -144,14 +205,11 @@ public class DownloadService extends IntentService {
     if (dest != null && !dest.isEmpty()) {
       intent.putExtra(FILEDEST, dest);
     }
-    if (error != null && !error.isEmpty()) {
-      intent.putExtra(ERROR, error);
-    }
+    intent.putExtra(ERROR, error);
     intent.putExtra(ID, id);
     intent.putExtra(VERSION, version);
     intent.putExtra(SESSIONKEY, sessionKey);
     intent.putExtra(CHECKSUM, checksum);
-    intent.putExtra(ERROR, error);
     intent.putExtra(SIGNATURE, signature);
     sendBroadcast(intent);
   }

package/ios/Plugin/CapacitorUpdater.swift

@@ -237,7 +237,7 @@ extension CustomError: LocalizedError {
 }
 
 @objc public class CapacitorUpdater: NSObject {
-
+    
     private let versionCode: String = Bundle.main.versionCode ?? ""
     private let versionOs = UIDevice.current.systemVersion
     private let libraryDir: URL = FileManager.default.urls(for: .libraryDirectory, in: .userDomainMask).first!
@@ -247,7 +247,7 @@ extension CustomError: LocalizedError {
     private let FALLBACK_VERSION: String = "pastVersion"
     private let NEXT_VERSION: String = "nextVersion"
     private var unzipPercent = 0
-
+    
     public let TAG: String = "✨  Capacitor-updater:"
     public let CAP_SERVER_PATH: String = "serverBasePath"
     public var versionBuild: String = ""
@@ -261,7 +261,11 @@ extension CustomError: LocalizedError {
     public var deviceID = UIDevice.current.identifierForVendor?.uuidString ?? ""
     public var privateKey: String = ""
     public var signKey: PublicKey?
-
+    
+    public var notifyDownloadRaw: (String, Int, Bool) -> Void = { _, _, _  in }
+    public func notifyDownload(id: String, percent: Int, ignoreMultipleOfTen: Bool = false) {
+        notifyDownloadRaw(id, percent, ignoreMultipleOfTen)
+    }
     public var notifyDownload: (String, Int) -> Void = { _, _  in }
 
     private func calcTotalPercent(percent: Int, min: Int, max: Int) -> Int {
@@ -356,34 +360,7 @@ extension CustomError: LocalizedError {
         }
     }
 
-    private func calcChecksum(filePath: URL) -> String {
-        let bufferSize = 1024 * 1024 * 5 // 5 MB
-        var checksum = uLong(0)
-
-        do {
-            let fileHandle = try FileHandle(forReadingFrom: filePath)
-            defer {
-                fileHandle.closeFile()
-            }
 
-            while autoreleasepool(invoking: {
-                let fileData = fileHandle.readData(ofLength: bufferSize)
-                if fileData.count > 0 {
-                    checksum = fileData.withUnsafeBytes {
-                        crc32(checksum, $0.bindMemory(to: Bytef.self).baseAddress, uInt(fileData.count))
-                    }
-                    return true // Continue
-                } else {
-                    return false // End of file
-                }
-            }) {}
-
-            return String(format: "%08X", checksum).lowercased()
-        } catch {
-            print("\(self.TAG) Cannot calc checksum: \(filePath.path)", error)
-            return ""
-        }
-    }
     
     private func verifyBundleSignature(version: String, filePath: URL, signature: String?) throws -> Bool {
         if (self.signKey == nil) {
@@ -447,6 +424,7 @@ extension CustomError: LocalizedError {
             }
 
             try decryptedData.write(to: filePath)
+           
         } catch {
             print("\(self.TAG) Cannot decode: \(filePath.path)", error)
             self.sendStats(action: "decrypt_fail", versionName: version)
@@ -485,7 +463,7 @@ extension CustomError: LocalizedError {
         let newPercent = self.calcTotalPercent(percent: Int(Double(entryNumber) / Double(total) * 100), min: 75, max: 81)
         if newPercent != self.unzipPercent {
             self.unzipPercent = newPercent
-            self.notifyDownload(id, newPercent)
+            self.notifyDownload(id: id, percent: newPercent)
         }
     }
 
@@ -495,7 +473,7 @@ extension CustomError: LocalizedError {
         let destUnZip: URL = libraryDir.appendingPathComponent(randomString(length: 10))
 
         self.unzipPercent = 0
-        self.notifyDownload(id, 75)
+        self.notifyDownload(id: id, percent: 75)
 
         let semaphore = DispatchSemaphore(value: 0)
         var unzipError: NSError?
@@ -605,81 +583,107 @@ extension CustomError: LocalizedError {
         UserDefaults.standard.synchronize()
         print("\(self.TAG) Current bundle set to: \((bundle ).isEmpty ? BundleInfo.ID_BUILTIN : bundle)")
     }
+    private func calcChecksum(filePath: URL) -> String {
+        let bufferSize = 1024 * 1024 * 5 // 5 MB
+        var checksum = uLong(0)
 
-    public func download(url: URL, version: String, sessionKey: String, signature: String?) throws -> BundleInfo {
-        let semaphore: DispatchSemaphore = DispatchSemaphore(value: 0)
-        let id: String = self.randomString(length: 10)
-        var checksum: String = ""
+        do {
+            let fileHandle = try FileHandle(forReadingFrom: filePath)
+            defer {
+                fileHandle.closeFile()
+            }
 
-        var mainError: NSError?
-        let destination: DownloadRequest.Destination = { _, _ in
-            let documentsURL: URL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
-            let fileURL: URL = documentsURL.appendingPathComponent(self.randomString(length: 10))
+            while autoreleasepool(invoking: {
+                let fileData = fileHandle.readData(ofLength: bufferSize)
+                if fileData.count > 0 {
+                    checksum = fileData.withUnsafeBytes {
+                        crc32(checksum, $0.bindMemory(to: Bytef.self).baseAddress, uInt(fileData.count))
+                    }
+                    return true // Continue
+                } else {
+                    return false // End of file
+                }
+            }) {}
 
-            return (fileURL, [.removePreviousFile, .createIntermediateDirectories])
+            return String(format: "%08X", checksum).lowercased()
+        } catch {
+            print("\(self.TAG) Cannot get checksum: \(filePath.path)", error)
+            return ""
         }
-        let request = AF.download(url, to: destination)
+    }
+    
+    private var tempDataPath: URL {
+        return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent("package.tmp")
+    }
 
-        request.downloadProgress { progress in
-            let percent = self.calcTotalPercent(percent: Int(progress.fractionCompleted * 100), min: 10, max: 70)
-            self.notifyDownload(id, percent)
+    private var updateInfo: URL {
+        return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent("update.dat")
+    }
+    private var tempData = Data()
+    public func download(url: URL, version: String, sessionKey: String, signature: String) throws -> BundleInfo {
+        let id: String = self.randomString(length: 10)
+        let semaphore = DispatchSemaphore(value: 0)
+        if(version != getLocalUpdateVersion()){
+            cleanDlData()
         }
-        request.responseURL(queue: .global(qos: .background), completionHandler: { (response) in
-            if let fileURL = response.fileURL {
-                switch response.result {
-                case .success:
-                    self.notifyDownload(id, 71)
-                    
-                    // The reason we do 2 blocks of try/catch is that in the first one we will try to cleanup afterwards. Cleanup wlll NOT happen in the second one
-                    
-                    do {
-                        let valid = try self.verifyBundleSignature(version: version, filePath: fileURL, signature: signature)
-                        if (!valid) {
-                            print("\(self.TAG) Invalid signature, cannot accept download")
-                            self.sendStats(action: "invalid_signature", versionName: version)
-                            throw CustomError.invalidSignature
-                        } else {
-                            print("\(self.TAG) Valid signature")
-                        }
-                        
-                        try self.decryptFile(filePath: fileURL, sessionKey: sessionKey, version: version)
-                        checksum = self.calcChecksum(filePath: fileURL)
-                    } catch {
-                        print("\(self.TAG) downloaded file verification error", error)
-                        mainError = error as NSError
-                        
-                        // Cleanup
-                        do {
-                            try self.deleteFolder(source: fileURL)
-                        } catch {
-                            print("\(self.TAG) Double error, cannot cleanup", error)
-                        }
-                    }
-                    
-                    do {
-                        if (mainError == nil) {
-                            try self.saveDownloaded(sourceZip: fileURL, id: id, base: self.libraryDir.appendingPathComponent(self.bundleDirectory), notify: true)
-                            try self.deleteFolder(source: fileURL)
-                            self.notifyDownload(id, 100)
-                        }
-                    } catch {
-                        print("\(self.TAG) download unzip error", error)
-                        mainError = error as NSError
-                    }
-                case let .failure(error):
-                    print("\(self.TAG) download error", response.value ?? "", error)
-                    if let afError = error as? AFError,
-                       case .sessionTaskFailed(let urlError as URLError) = afError,
-                       urlError.code == .cannotWriteToFile {
-                        self.sendStats(action: "low_mem_fail", versionName: version)
-                    }
-                    mainError = error as NSError
-                }
+        ensureResumableFilesExist()
+        saveDownloadInfo(version)
+        var checksum = ""
+        var targetSize = -1
+        var lastSentProgress = 0
+        var totalReceivedBytes: Int64 = loadDownloadProgress() //Retrieving the amount of already downloaded data if exist, defined at 0 otherwise
+         let requestHeaders: HTTPHeaders = ["Range": "bytes=\(totalReceivedBytes)-"]
+        //Opening connection for streaming the bytes
+        if(totalReceivedBytes == 0){
+            self.notifyDownload(id: id, percent: 0, ignoreMultipleOfTen: true)
+        }
+        var mainError: NSError?
+        let monitor = ClosureEventMonitor()
+        monitor.requestDidCompleteTaskWithError = { (request, task, error) in
+            if error != nil {
+                print("\(self.TAG) Downloading failed - ClosureEventMonitor activated")
+                mainError = error as NSError?
             }
-            semaphore.signal()
-        })
+        }
+        let session = Session(eventMonitors: [monitor])
+
+        var request = session.streamRequest(url, headers: requestHeaders).validate().onHTTPResponse(perform: { response  in
+            if let contentLength = response.headers.value(for: "Content-Length") {
+                targetSize = (Int(contentLength) ?? -1) + Int(totalReceivedBytes)
+            }
+        }).responseStream { [weak self] streamResponse in
+             guard let self = self else { return }
+             switch streamResponse.event {
+             case .stream(let result):
+                 if case .success(let data) = result {
+                     self.tempData.append(data)
+                     
+                     self.savePartialData(startingAt: UInt64(totalReceivedBytes)) // Saving the received data in the package.tmp file
+                     totalReceivedBytes += Int64(data.count)
+                     
+                     let percent = Int((Double(totalReceivedBytes) / Double(targetSize)) * 100.0)
+                     
+                     print("\(self.TAG) Downloading: \(percent)%")
+                     let currentMilestone = (percent / 10) * 10
+                             if currentMilestone > lastSentProgress && currentMilestone <= 70 {
+                                 for milestone in stride(from: lastSentProgress + 10, through: currentMilestone, by: 10) {
+                                     self.notifyDownload(id: id, percent: milestone, ignoreMultipleOfTen: true)
+                                 }
+                                 lastSentProgress = currentMilestone
+                             }
+
+                 }
+                 else {
+                     print("\(self.TAG) Download failed")
+                 }
+
+
+             case .complete(_):
+                print("\(self.TAG) Download complete, total received bytes: \(totalReceivedBytes)")
+                semaphore.signal()
+             }
+        }
         self.saveBundleInfo(id: id, bundle: BundleInfo(id: id, version: version, status: BundleStatus.DOWNLOADING, downloaded: Date(), checksum: checksum))
-        self.notifyDownload(id, 0)
         let reachabilityManager = NetworkReachabilityManager()
         reachabilityManager?.startListening { status in
             switch status {
@@ -694,13 +698,144 @@ extension CustomError: LocalizedError {
         }
         semaphore.wait()
         reachabilityManager?.stopListening()
-        if let error = mainError {
+
+        if (mainError != nil) {
+            print("\(self.TAG) Failed to download: \(String(describing: mainError))")
+            self.saveBundleInfo(id: id, bundle: BundleInfo(id: id, version: version, status: BundleStatus.ERROR, downloaded: Date(), checksum: checksum))
+            throw mainError!
+        }
+        
+        let finalPath = tempDataPath.deletingLastPathComponent().appendingPathComponent("\(id)")
+        do {
+            let valid = try self.verifyBundleSignature(version: version, filePath: tempDataPath, signature: signature)
+            if (!valid) {
+                print("\(self.TAG) Invalid signature, cannot accept download")
+                self.sendStats(action: "invalid_signature", versionName: version)
+                throw CustomError.invalidSignature
+            } else {
+                print("\(self.TAG) Valid signature")
+            }
+            
+            try self.decryptFile(filePath: tempDataPath, sessionKey: sessionKey, version: version)
+            try FileManager.default.moveItem(at: tempDataPath, to: finalPath)
+        } catch {
+            print("\(self.TAG) Failed decrypt file or verify signature or move it: \(error)")
+            self.saveBundleInfo(id: id, bundle: BundleInfo(id: id, version: version, status: BundleStatus.ERROR, downloaded: Date(), checksum: checksum))
+            cleanDlData()
+            throw error
+        }
+        
+        do {
+            checksum = self.calcChecksum(filePath: finalPath)
+            try self.saveDownloaded(sourceZip: finalPath, id: id, base: self.libraryDir.appendingPathComponent(self.bundleDirectory), notify: true)
+        } catch {
+            print("\(self.TAG) Failed to unzip file: \(error)")
+            self.saveBundleInfo(id: id, bundle: BundleInfo(id: id, version: version, status: BundleStatus.ERROR, downloaded: Date(), checksum: checksum))
+            cleanDlData()
+            // todo: cleanup zip attempts
             throw error
         }
-        let info: BundleInfo = BundleInfo(id: id, version: version, status: BundleStatus.PENDING, downloaded: Date(), checksum: checksum)
+        
+        let info = BundleInfo(id: id, version: version, status: BundleStatus.PENDING, downloaded: Date(), checksum: checksum)
         self.saveBundleInfo(id: id, bundle: info)
+        self.notifyDownload(id: id, percent: 100)
+        self.cleanDlData()
         return info
     }
+    private func ensureResumableFilesExist() {
+        let fileManager = FileManager.default
+        if !fileManager.fileExists(atPath: tempDataPath.path) {
+            if !fileManager.createFile(atPath: tempDataPath.path, contents: Data()) {
+                print("\(self.TAG) Cannot ensure that a file at \(tempDataPath.path) exists")
+            }
+        }
+        
+        if !fileManager.fileExists(atPath: updateInfo.path) {
+            if !fileManager.createFile(atPath: updateInfo.path, contents: Data()) {
+                print("\(self.TAG) Cannot ensure that a file at \(updateInfo.path) exists")
+            }
+        }
+    }
+    
+    private func cleanDlData(){
+        // Deleting package.tmp
+        let fileManager = FileManager.default
+        if fileManager.fileExists(atPath: tempDataPath.path) {
+             do {
+                 try fileManager.removeItem(at: tempDataPath)
+             } catch {
+                 print("\(self.TAG) Could not delete file at \(tempDataPath): \(error)")
+             }
+         } else {
+             print("\(self.TAG) \(tempDataPath.lastPathComponent) does not exist")
+         }
+         
+         // Deleting update.dat
+         if fileManager.fileExists(atPath: updateInfo.path) {
+             do {
+                 try fileManager.removeItem(at: updateInfo)
+             } catch {
+                 print("\(self.TAG) Could not delete file at \(updateInfo): \(error)")
+             }
+         } else {
+             print("\(self.TAG) \(updateInfo.lastPathComponent) does not exist")
+         }
+    }
+    
+    private func savePartialData(startingAt byteOffset: UInt64) {
+        let fileManager = FileManager.default
+        do {
+            // Check if package.tmp exist
+            if !fileManager.fileExists(atPath: tempDataPath.path) {
+                try self.tempData.write(to: tempDataPath, options: .atomicWrite)
+            } else {
+                // If yes, it start writing on it
+                let fileHandle = try FileHandle(forWritingTo: tempDataPath)
+                fileHandle.seek(toFileOffset: byteOffset) // Moving at the specified position to start writing
+                fileHandle.write(self.tempData)
+                fileHandle.closeFile()
+            }
+        } catch {
+            print("Failed to write data starting at byte \(byteOffset): \(error)")
+        }
+        self.tempData.removeAll() // Clearing tempData to avoid writing the same data multiple times
+    }
+
+
+    private func saveDownloadInfo(_ version: String) {
+        do {
+            try "\(version)".write(to: updateInfo, atomically: true, encoding: .utf8)
+        } catch {
+            print("\(self.TAG) Failed to save progress: \(error)")
+        }
+    }
+    private func getLocalUpdateVersion() -> String { //Return the version that was tried to be downloaded on last download attempt
+        if !FileManager.default.fileExists(atPath: updateInfo.path) {
+            return "nil"
+        }
+         guard let versionString = try? String(contentsOf: updateInfo),
+               let version = Optional(versionString) else {
+             return "nil"
+         }
+         return version
+     }
+    private func loadDownloadProgress() -> Int64 {
+        
+        let fileManager = FileManager.default
+         do {
+             let attributes = try fileManager.attributesOfItem(atPath: tempDataPath.path)
+             if let fileSize = attributes[.size] as? NSNumber {
+                 return fileSize.int64Value
+             }
+         } catch {
+             print("\(self.TAG) Could not retrieve already downloaded data size : \(error)")
+         }
+         return 0
+    }
+
+
+
+
 
     public func list() -> [BundleInfo] {
         let dest: URL = libraryDir.appendingPathComponent(bundleDirectory)

package/ios/Plugin/CapacitorUpdaterPlugin.swift

@@ -16,7 +16,7 @@ import SwiftyRSA
 @objc(CapacitorUpdaterPlugin)
 public class CapacitorUpdaterPlugin: CAPPlugin {
     public var implementation = CapacitorUpdater()
-    private let PLUGIN_VERSION: String = "6.1.2"
+    private let PLUGIN_VERSION: String = "6.1.4"
     static let updateUrlDefault = "https://api.capgo.app/updates"
     static let statsUrlDefault = "https://api.capgo.app/stats"
     static let channelUrlDefault = "https://api.capgo.app/channel_self"
@@ -74,7 +74,7 @@ public class CapacitorUpdaterPlugin: CAPPlugin {
         }
 
         implementation.privateKey = getConfig().getString("privateKey", self.defaultPrivateKey)!
-        implementation.notifyDownload = notifyDownload
+        implementation.notifyDownloadRaw = notifyDownload
         implementation.PLUGIN_VERSION = self.PLUGIN_VERSION
         let config = (self.bridge?.viewController as? CAPBridgeViewController)?.instanceDescriptor().legacyConfig
         implementation.appId = Bundle.main.infoDictionary?["CFBundleIdentifier"] as? String ?? ""
@@ -173,13 +173,13 @@ public class CapacitorUpdaterPlugin: CAPPlugin {
         UserDefaults.standard.synchronize()
     }
 
-    @objc func notifyDownload(id: String, percent: Int) {
+    @objc func notifyDownload(id: String, percent: Int, ignoreMultipleOfTen: Bool = false) {
         let bundle = self.implementation.getBundleInfo(id: id)
         self.notifyListeners("download", data: ["percent": percent, "bundle": bundle.toJSON()])
         if percent == 100 {
             self.notifyListeners("downloadComplete", data: ["bundle": bundle.toJSON()])
             self.implementation.sendStats(action: "download_complete", versionName: bundle.getVersionName())
-        } else if percent.isMultiple(of: 10) {
+        } else if percent.isMultiple(of: 10) || ignoreMultipleOfTen {
             self.implementation.sendStats(action: "download_\(percent)", versionName: bundle.getVersionName())
         }
     }
@@ -721,6 +721,9 @@ public class CapacitorUpdaterPlugin: CAPPlugin {
                                 print("\(self.implementation.TAG) Failed to delete failed bundle: \(nextImpl!.toString())")
                             }
                         }
+                        guard let signature = signature else {
+                            throw CustomError.signatureNotProvided
+                        }
                         nextImpl = try self.implementation.download(url: downloadUrl, version: latestVersionName, sessionKey: sessionKey, signature: signature)
                     }
                     guard let next = nextImpl else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-updater",
-  "version": "6.1.2",
+  "version": "6.1.4",
   "license": "MPL-2.0",
   "description": "Live update for capacitor apps",
   "main": "dist/plugin.cjs.js",