implement download feature

DynamicIsland/managers/DownloadManager.swift

@@ -0,0 +1,281 @@
+import Foundation
+import Defaults
+import SwiftUI
+
+@MainActor
+class DownloadManager: ObservableObject {
+    static let shared = DownloadManager()
+    
+    @Published private(set) var isDownloading: Bool = false
+    @Published private(set) var isDownloadCompleted: Bool = false
+    
+    private let coordinator = DynamicIslandViewCoordinator.shared
+    private var source: DispatchSourceFileSystemObject?
+    private let queue = DispatchQueue(label: "com.dynamicisland.downloads.monitor", qos: .utility)
+    private var completionTimer: Timer?
+    private var hasPerformedInitialScan: Bool = false
+    private var initialCrDownloadFiles: Set<String> = []
+    private var previousAllFiles: Set<String> = []
+    
+    private var ignoredFiles: Set<String> = []
+    
+    private var downloadsDirectory: URL? {
+        FileManager.default.urls(for: .downloadsDirectory, in: .userDomainMask).first
+    }
+    
+    private init() {
+        requestDownloadsPermissionIfNeeded()
+        startMonitoringIfNeeded()
+        
+        Defaults.publisher(.enableDownloadListener)
+            .sink { [weak self] change in
+                guard let self else { return }
+                Task { @MainActor in
+                    self.startMonitoringIfNeeded()
+                }
+            }
+    }
+    
+    private func startMonitoringIfNeeded() {
+        if Defaults[.enableDownloadListener] {
+            startMonitoring()
+        } else {
+            stopMonitoring()
+            updateDownloadingState(isActive: false)
+        }
+    }
+    
+    private func startMonitoring() {
+        guard source == nil, let downloadsDirectory else { return }
+        
+        hasPerformedInitialScan = false
+        initialCrDownloadFiles.removeAll()
+        previousAllFiles.removeAll()
+        ignoredFiles.removeAll()
+        isDownloading = false
+        
+        let path = downloadsDirectory.path
+        let fd = open(path, O_EVTONLY)
+        guard fd >= 0 else {
+            print("DownloadManager: Failed to open Downloads directory at \(path)")
+            return
+        }
+        
+        let src = DispatchSource.makeFileSystemObjectSource(
+            fileDescriptor: fd,
+            eventMask: [.write, .rename, .delete, .attrib],
+            queue: queue
+        )
+        
+        src.setEventHandler { [weak self] in
+            self?.scanDownloadsDirectory()
+        }
+        
+        src.setCancelHandler {
+            close(fd)
+        }
+        
+        source = src
+        src.resume()
+        
+        // Initial scan
+        scanDownloadsDirectory()
+        
+        print("DownloadManager: Started monitoring Downloads folder at \(path)")
+    }
+    
+    private func stopMonitoring() {
+        source?.cancel()
+        source = nil
+        hasPerformedInitialScan = false
+        initialCrDownloadFiles.removeAll()
+        previousAllFiles.removeAll()
+        ignoredFiles.removeAll()
+        isDownloading = false
+        print("DownloadManager: Stopped monitoring Downloads folder")
+    }
+    
+    private func scanDownloadsDirectory() {
+        guard let downloadsDirectory else { return }
+        
+        let crDownloadFiles: Set<String>
+        let allFiles: Set<String>
+        do {
+            let contents = try FileManager.default.contentsOfDirectory(
+                at: downloadsDirectory,
+                includingPropertiesForKeys: [.creationDateKey],
+                options: [.skipsHiddenFiles]
+            )
+            crDownloadFiles = Set(contents
+                .filter { 
+                    let ext = $0.pathExtension.lowercased()
+                    return ext == "crdownload" || ext == "download"
+                }
+                .map { $0.lastPathComponent }
+            )
+            allFiles = Set(contents.map { $0.lastPathComponent })
+        } catch {
+            print("DownloadManager: Failed to read Downloads directory: \(error)")
+            crDownloadFiles = []
+            allFiles = []
+        }
+        
+        Task { @MainActor in
+            self.processDownloadFiles(crDownloadFiles, allFiles: allFiles)
+        }
+    }
+    
+    private func processDownloadFiles(_ crDownloadFiles: Set<String>, allFiles: Set<String>) {
+        // Initial scan - track and ignore existing files
+        if !hasPerformedInitialScan {
+            hasPerformedInitialScan = true
+            initialCrDownloadFiles = crDownloadFiles
+            previousAllFiles = allFiles
+            ignoredFiles = crDownloadFiles
+            isDownloading = false
+            print("DownloadManager: initial scan - found \(crDownloadFiles.count) existing files, ignoring")
+            return
+        }
+        
+        // Calculate differences
+        let newFiles = crDownloadFiles.subtracting(initialCrDownloadFiles)
+        let disappearedFiles = initialCrDownloadFiles.subtracting(crDownloadFiles)
+        let newRegularFiles = allFiles.subtracting(previousAllFiles).subtracting(crDownloadFiles)
+        
+        // Log disappeared files
+        if !disappearedFiles.isEmpty {
+            print("DownloadManager: files disappeared: \(disappearedFiles.joined(separator: ", "))")
+            ignoredFiles.subtract(disappearedFiles)
+        }
+        
+        // Log new regular files (potential completed downloads)
+        if !newRegularFiles.isEmpty {
+            print("DownloadManager: new regular files appeared: \(newRegularFiles.joined(separator: ", "))")
+        }
+        
+        // Update tracked files BEFORE calculating active files
+        initialCrDownloadFiles = crDownloadFiles
+        previousAllFiles = allFiles
+        
+        // Calculate active downloads
+        let activeFiles = crDownloadFiles.subtracting(ignoredFiles)
+        let hasActiveDownloads = !activeFiles.isEmpty
+        
+        
+        // Handle new downloads
+        if !newFiles.isEmpty {
+            let newActiveFiles = newFiles.subtracting(ignoredFiles)
+            if !newActiveFiles.isEmpty {
+                print("DownloadManager: new download detected: \(newActiveFiles.joined(separator: ", "))")
+                
+                if !isDownloading {
+                    updateDownloadingState(isActive: true)
+                }
+            }
+        }
+        
+        // Handle state changes based on active downloads
+        if isDownloading {
+            if !hasActiveDownloads {
+                // No more active downloads
+                // Check if new regular files appeared (indicating successful completion)
+                if !newRegularFiles.isEmpty || disappearedFiles.isEmpty {
+                    // Download completed successfully - show completion state
+                    if !isDownloadCompleted {
+                        print("DownloadManager: download completed successfully - showing completion")
+                        updateDownloadingState(isActive: false)
+                    }
+                } else {
+                    // Download files disappeared but no new regular files appeared - cancelled
+                    print("DownloadManager: download cancelled - closing immediately")
+                    closeDownloadViewImmediately()
+                }
+            } else if !disappearedFiles.isEmpty {
+                // Some downloads finished but others remain
+                print("DownloadManager: some finished, \(activeFiles.count) still active")
+            }
+        } else if hasActiveDownloads {
+            // We're not showing UI but we have active downloads - this shouldn't happen
+            // but let's handle it gracefully
+            print("DownloadManager: active downloads found but UI closed - reopening")
+            updateDownloadingState(isActive: true)
+        }
+    }
+    
+    private func requestDownloadsPermissionIfNeeded() {
+        guard let downloadsDirectory else { return }
+        
+        _ = try? FileManager.default.contentsOfDirectory(
+            at: downloadsDirectory,
+            includingPropertiesForKeys: nil,
+            options: [.skipsHiddenFiles]
+        )
+    }
+    
+    private func updateDownloadingState(isActive: Bool) {
+        completionTimer?.invalidate()
+        completionTimer = nil
+        
+        if isActive {
+            isDownloadCompleted = false
+            
+            if !isDownloading {
+                withAnimation(.smooth) {
+                    isDownloading = true
+                }
+                print("DownloadManager: download started")
+                coordinator.toggleExpandingView(
+                    status: true,
+                    type: .download,
+                    value: 0,
+                    browser: .chromium
+                )
+            }
+        } else {
+            if isDownloading {
+                print("DownloadManager: download finished - showing completion")
+                withAnimation(.smooth) {
+                    isDownloadCompleted = true
+                }
+                
+                // Close after 2 seconds
+                completionTimer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { [weak self] _ in
+                    Task { @MainActor in
+                        self?.closeDownloadView()
+                    }
+                }
+            }
+        }
+    }
+    
+    private func closeDownloadView() {
+        withAnimation(.smooth) {
+            isDownloading = false
+            isDownloadCompleted = false
+        }
+        print("DownloadManager: closing download view")
+        coordinator.toggleExpandingView(
+            status: false,
+            type: .download,
+            value: 0,
+            browser: .chromium
+        )
+    }
+    
+    private func closeDownloadViewImmediately() {
+        completionTimer?.invalidate()
+        completionTimer = nil
+        
+        withAnimation(.smooth) {
+            isDownloading = false
+            isDownloadCompleted = false
+        }
+        print("DownloadManager: closing download view immediately (cancelled)")
+        coordinator.toggleExpandingView(
+            status: false,
+            type: .download,
+            value: 0,
+            browser: .chromium
+        )
+    }
+}