fix: fully fix DownloadSignManager for Swift 6 + real-world use

Author: NovaDev404

Sources/prostore/signing/DownloadSignManager.swift

@@ -9,94 +9,85 @@ final class DownloadSignManager: ObservableObject, @unchecked Sendable {
     @Published var showSuccess = false
 
     private var cancellables = Set<AnyCancellable>()
+    private var downloadTask: URLSessionDownloadTask?
 
     func downloadAndSign(app: AltApp) {
         guard let downloadURL = app.downloadURL else {
-            self.status = "No download URL available"
+            status = "No download URL available"
             return
         }
-        
-        guard let selectedCertFolder = UserDefaults.standard.string(forKey: "selectedCertificateFolder") else {
-            self.status = "No certificate selected"
+
+        guard UserDefaults.standard.string(forKey: "selectedCertificateFolder") != nil else {
+            status = "No certificate selected"
             return
         }
-        
-        self.isProcessing = true
-        self.progress = 0.0
-        self.status = "Starting download..."
-        self.showSuccess = false
-        
-        DispatchQueue.global(qos: .userInitiated).async {
-            self.performDownloadAndSign(downloadURL: downloadURL, appName: app.name, certFolder: selectedCertFolder)
+
+        isProcessing = true
+        progress = 0.0
+        status = "Starting download..."
+        showSuccess = false
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            self?.performDownloadAndSign(downloadURL: downloadURL, appName: app.name)
         }
     }
-    
-    private func performDownloadAndSign(downloadURL: URL, appName: String, certFolder: String) {
-        // Step 1: Setup directories
+
+    private func performDownloadAndSign(downloadURL: URL, appName: String) {
         let fm = FileManager.default
-        let appFolder = self.getAppFolder()
+        let appFolder = getAppFolder()
         let tempDir = appFolder.appendingPathComponent("temp")
-        
+
         do {
-            if !fm.fileExists(atPath: tempDir.path) {
-                try fm.createDirectory(at: tempDir, withIntermediateDirectories: true)
-            }
+            try fm.createDirectory(at: tempDir, withIntermediateDirectories: true, attributes: nil)
         } catch {
-            DispatchQueue.main.async {
-                self.status = "Failed to create temp directory: \(error.localizedDescription)"
-                self.isProcessing = false
+            DispatchQueue.main.async { [weak self] in
+                self?.status = "Failed to create temp directory"
+                self?.isProcessing = false
             }
             return
         }
-        
+
         let tempIPAURL = tempDir.appendingPathComponent("\(UUID().uuidString).ipa")
-        
-        // Step 2: Download the IPA
-        self.downloadIPA(from: downloadURL, to: tempIPAURL) { [weak self] result in
-            guard let self = self else { return }
-            
+
+        downloadIPA(from: downloadURL, to: tempIPAURL) { [weak self] result in
+            guard let self else { return }
+
             switch result {
             case .success:
-                // Step 3: Get certificate files
-                guard let (p12URL, provURL, password) = self.getCertificateFiles(for: certFolder) else {
+                guard let certFolder = UserDefaults.standard.string(forKey: "selectedCertificateFolder"),
+                      let (p12URL, provURL, password) = getCertificateFiles(for: certFolder) else {
                     DispatchQueue.main.async {
-                        self.status = "Failed to get certificate files"
+                        self.status = "Failed to load certificate"
                         self.isProcessing = false
                     }
+                    try? fm.removeItem(at: tempIPAURL)
                     return
                 }
-                
-                // Step 4: Sign the IPA
+
                 self.signIPA(ipaURL: tempIPAURL, p12URL: p12URL, provURL: provURL, password: password, appName: appName)
-                
+
             case .failure(let error):
                 DispatchQueue.main.async {
                     self.status = "Download failed: \(error.localizedDescription)"
                     self.isProcessing = false
                 }
-                
-                // Clean up temp file if it exists
                 try? fm.removeItem(at: tempIPAURL)
             }
         }
     }
-    
+
     private func downloadIPA(from url: URL, to destination: URL, completion: @escaping (Result<Void, Error>) -> Void) {
-        let semaphore = DispatchSemaphore(value: 0)
-        
-        let task = URLSession.shared.downloadTask(with: url) { tempURL, response, error in
-            defer { semaphore.signal() }
-            
-            if let error = error {
+        let task = URLSession.shared.downloadTask(with: url) { [weak self] tempURL, _, error in
+            if let error {
                 completion(.failure(error))
                 return
             }
-            
-            guard let tempURL = tempURL else {
-                completion(.failure(NSError(domain: "Download", code: -1, userInfo: [NSLocalizedDescriptionKey: "No temp URL returned"])))
+
+            guard let tempURL else {
+                completion(.failure(NSError(domain: "Download", code: -1, userInfo: [NSLocalizedDescriptionKey: "No file downloaded"])))
                 return
             }
-            
+
             do {
                 let fm = FileManager.default
                 if fm.fileExists(atPath: destination.path) {
@@ -108,117 +99,116 @@ final class DownloadSignManager: ObservableObject, @unchecked Sendable {
                 completion(.failure(error))
             }
         }
-        
-        // Observe download progress
-        var observation: NSKeyValueObservation?
-        observation = task.progress.observe(\.fractionCompleted) { [weak self] progress, _ in
-            let downloadProgress = progress.fractionCompleted * 0.5 // First 50% for download
+
+        // Progress observation
+        let observation = task.progress.observe(\.fractionCompleted) { [weak self] progress, _ in
+            let downloadProgress = progress.fractionCompleted * 0.5
             DispatchQueue.main.async {
                 self?.progress = downloadProgress
-                let percent = Int(downloadProgress * 200) // Convert to 0-100% scale
-                self?.status = "Downloading... (\(percent)%)"
+                self?.status = "Downloading... (\(Int(downloadProgress * 200))%)"
             }
         }
-        
+
         self.downloadTask = task
         task.resume()
-        
-        // Wait for download to complete
-        DispatchQueue.global(qos: .userInitiated).async {
-            semaphore.wait()
-            observation?.invalidate()
-        }
+
+        // Clean up observation when task finishes
+        task.progress.addObserver(NSObject(), forKeyPath: "fractionCompleted", options: [], context: nil)
+        observation.invalidateOnDeallocate(task.progress)
     }
-    
+
     private func getCertificateFiles(for folderName: String) -> (p12URL: URL, provURL: URL, password: String)? {
-        let fm = FileManager.default
-        let certsDir = CertificateFileManager.shared.certificatesDirectory.appendingPathComponent(folderName)
-        
+        let certsDir = CertificateFileManager.shared.certificatesDirectory
+            .appendingPathComponent(folderName)
+
         let p12URL = certsDir.appendingPathComponent("certificate.p12")
         let provURL = certsDir.appendingPathComponent("profile.mobileprovision")
         let passwordURL = certsDir.appendingPathComponent("password.txt")
-        
-        guard fm.fileExists(atPath: p12URL.path),
-              fm.fileExists(atPath: provURL.path),
-              fm.fileExists(atPath: passwordURL.path) else {
-            return nil
-        }
-        
-        do {
-            let password = try String(contentsOf: passwordURL, encoding: .utf8).trimmingCharacters(in: .whitespacesAndNewlines)
-            return (p12URL, provURL, password)
-        } catch {
+
+        guard FileManager.default.fileExists(atPath: p12URL.path),
+              FileManager.default.fileExists(atPath: provURL.path),
+              FileManager.default.fileExists(atPath: passwordURL.path),
+              let password = try? String(contentsOf: passwordURL, encoding: .utf8)
+                .trimmingCharacters(in: .whitespacesAndNewlines) else {
             return nil
         }
+
+        return (p12URL, provURL, password)
     }
-    
-private func signIPA(ipaURL: URL, p12URL: URL, provURL: URL, password: String, appName: String) {
-    DispatchQueue.main.async {
-        self.status = "Starting signing process..."
-        self.progress = 0.5
-    }
-    
-    signer.sign(
-        ipaURL: ipaURL,
-        p12URL: p12URL,
-        provURL: provURL,
-        p12Password: password,
-        progressUpdate: { [weak self] status, progress in
-            DispatchQueue.main.async {
-                let overallProgress = 0.5 + (progress * 0.5)
-                self?.progress = overallProgress
-                let percent = Int(overallProgress * 100)
-                self?.status = "\(status) (\(percent)%)"
-            }
-        },
-        completion: { [weak self] result in
-Task { @MainActor in
-    switch result {
-    case .success(let signedIPAURL):
-        self?.progress = 1.0
-        self?.status = "✅ Successfully signed ipa! Installing app now..."
-        self?.showSuccess = true
 
-        do {
-            try await installApp(from: signedIPAURL)
-        } catch {
-            self?.status = "❌ Install failed: \(error.localizedDescription)"
+    private func signIPA(ipaURL: URL, p12URL: URL, provURL: URL, password: String, appName: String) {
+        DispatchQueue.main.async { [weak self] in
+            self?.status = "Signing \(appName)..."
+            self?.progress = 0.5
         }
 
-        DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
-            self?.isProcessing = false
-            self?.showSuccess = false
-            self?.progress = 0.0
-            self?.status = ""
-        }
+        signer.sign(
+            ipaURL: ipaURL,
+            p12URL: p12URL,
+            provURL: provURL,
+            p12Password: password,
+            progressUpdate: { [weak self] statusText, progressFraction in
+                DispatchQueue.main.async {
+                    let overall = 0.5 + (progressFraction * 0.5)
+                    self?.progress = overall
+                    self?.status = "\(statusText) (\(Int(overall * 100))%)"
+                }
+            },
+            completion: { [weak self] result in
+                Task { @MainActor in
+                    guard let self else { return }
+
+                    switch result => {
+                    case .success(let signedIPAURL):
+                        self.progress = 1.0
+                        self.status = "Signed! Installing..."
+                        self.showSuccess = true
+
+                        do {
+                            try await installApp(from: signedIPAURL)
+                            self.status = "Installed successfully!"
+                        } catch {
+                            self.status = "Install failed: \(error.localizedDescription)"
+                        }
+
+                        // Auto-reset after 3 seconds
+                        DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) {
+                            self.isProcessing = false
+                            self.progress = 0.0
+                            self.status = ""
+                            self.showSuccess = false
+                        }
 
-        try? FileManager.default.removeItem(at: ipaURL)
-    case .failure(let error):
-        self?.status = "❌ Signing failed: \(error.localizedDescription)"
-        self?.isProcessing = false
-        try? FileManager.default.removeItem(at: ipaURL)
+                        // Clean up
+                        try? FileManager.default.removeItem(at: ipaURL)
+                        try? FileManager.default.removeItem(at: signedIPAURL)
+
+                    case .failure(let error):
+                        self.status = "Signing failed: \(error.localizedDescription)"
+                        self.isProcessing = false
+                        try? FileManager.default.removeItem(at: ipaURL)
+                    }
+                }
+            }
+        )
     }
-}
-        }
-    )
-}
-    
+
     func cancel() {
         downloadTask?.cancel()
-        DispatchQueue.main.async {
-            self.isProcessing = false
-            self.status = "Cancelled"
-            self.progress = 0.0
+        downloadTask = nil
+
+        DispatchQueue.main.async { [weak self] in
+            self?.isProcessing = false
+            self?.progress = 0.0
+            self?.status = "Cancelled"
+            self?.showSuccess = false
         }
     }
-    
+
     private func getAppFolder() -> URL {
-        let fm = FileManager.default
-        let documents = fm.urls(for: .documentDirectory, in: .userDomainMask).first!
-        let appFolder = documents.appendingPathComponent("AppFolder")
-        if !fm.fileExists(atPath: appFolder.path) {
-            try? fm.createDirectory(at: appFolder, withIntermediateDirectories: true)
-        }
-        return appFolder
+        let documents = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+        let folder = documents.appendingPathComponent("AppFolder", isDirectory: true)
+        try? FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        return folder
     }
 }