Fix Mac App by wrapping live activity stuff in ios only. Also work on making downloads continue in the backgriund but its not really working well yet

AtProtoBackup.xcodeproj/project.pbxproj

···
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = AtProtoBackup/Info.plist;
+				INFOPLIST_KEY_NSSupportsLiveActivities = YES;
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphoneos*]" = YES;
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphonesimulator*]" = YES;
 				"INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents[sdk=iphoneos*]" = YES;
···
 				ENABLE_PREVIEWS = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = AtProtoBackup/Info.plist;
+				INFOPLIST_KEY_NSSupportsLiveActivities = YES;
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphoneos*]" = YES;
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphonesimulator*]" = YES;
 				"INFOPLIST_KEY_UIApplicationSupportsIndirectInputEvents[sdk=iphoneos*]" = YES;

AtProtoBackup.xcodeproj/xcuserdata/coreyja.xcuserdatad/xcschemes/xcschememanagement.plist

···
 		<key>AtProtoBackup.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>0</integer>
+			<integer>1</integer>
 		</dict>
 		<key>WidgetExtensionExtension.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>1</integer>
+			<integer>0</integer>
 		</dict>
 	</dict>
 </dict>

AtProtoBackup/AppDelegate.swift

···
+//
+//  AppDelegate.swift
+//  AtProtoBackup
+//
+//  Created by Corey Alexander on 8/29/25.
+//
+#if os(iOS)
+import UIKit
+
+
+class AppDelegate: NSObject, UIApplicationDelegate {
+    func application(_ application: UIApplication, 
+                     handleEventsForBackgroundURLSession identifier: String, 
+                     completionHandler: @escaping () -> Void) {
+        print("[AppDelegate] Handling background URLSession events for identifier: \(identifier)")
+        
+        // Note: We can't update Live Activities here because we don't have
+        // access to the download progress from the BlobDownloader.
+        // Live Activities will show stale data until the app returns to foreground.
+        
+        // Let BlobDownloader handle the completion
+        BlobDownloader.handleEventsForBackgroundURLSession(
+            identifier: identifier,
+            completionHandler: completionHandler
+        )
+    }
+    
+    func applicationDidEnterBackground(_ application: UIApplication) {
+        // Request background processing time
+        var backgroundTask: UIBackgroundTaskIdentifier = .invalid
+        backgroundTask = application.beginBackgroundTask {
+            application.endBackgroundTask(backgroundTask)
+        }
+        
+        // You get ~30 seconds to update Live Activities
+        Task {
+            // Note: We could update Live Activities here but we don't have
+            // access to current download progress. The DownloadManager would
+            // need to expose this data for background updates to work.
+            application.endBackgroundTask(backgroundTask)
+        }
+    }
+}
+#endif

AtProtoBackup/AtProtoBackupApp.swift

···
 
 import SwiftUI
 import SwiftData
+#if os(iOS)
 import ActivityKit
+#endif
 
 @main
 struct AtProtoBackupApp: App {
+    #if os(iOS)
+    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
+    #endif
+    
     init() {
+        #if os(iOS)
         // Initialize Live Activity permissions check
         Task {
             await LiveActivityManager.shared.checkActivityPermissions()
         }
+        #endif
     }
     
     var sharedModelContainer: ModelContainer = {

AtProtoBackup/BackgroundDownloadTracker.swift

···
+//
+//  BackgroundDownloadTracker.swift
+//  AtProtoBackup
+//
+//  Created by Corey Alexander on 8/29/25.
+//
+
+import Foundation
+#if os(iOS)
+import ActivityKit
+#endif
+
+@MainActor
+class BackgroundDownloadTracker {
+    static let shared = BackgroundDownloadTracker()
+    
+    private var downloadProgress: [String: DownloadProgress] = [:]
+    #if os(iOS)
+    private var liveActivities: [String: Activity<DownloadActivityAttributes>] = [:]
+    private var lastUpdateCounts: [String: Int] = [:]
+    private let updateBatchSize = 10
+    #endif
+    
+    private struct DownloadProgress {
+        var downloadedBlobs: Int
+        var totalBlobs: Int
+        var lastUpdated: Date
+    }
+    
+    private init() {}
+    
+    func registerDownload(accountDid: String, totalBlobs: Int) {
+        downloadProgress[accountDid] = DownloadProgress(
+            downloadedBlobs: 0,
+            totalBlobs: totalBlobs,
+            lastUpdated: Date()
+        )
+        #if os(iOS)
+        lastUpdateCounts[accountDid] = 0
+        #endif
+    }
+    
+    #if os(iOS)
+    func registerLiveActivity(_ activity: Activity<DownloadActivityAttributes>, for accountDid: String) {
+        liveActivities[accountDid] = activity
+    }
+    #endif
+    
+    func incrementProgress(for accountDid: String) async {
+        guard var progress = downloadProgress[accountDid] else { return }
+        
+        progress.downloadedBlobs += 1
+        progress.lastUpdated = Date()
+        downloadProgress[accountDid] = progress
+        
+        #if os(iOS)
+        // Check if we should update the Live Activity (every 10 downloads)
+        let currentCount = lastUpdateCounts[accountDid] ?? 0
+        let newCount = currentCount + 1
+        lastUpdateCounts[accountDid] = newCount
+        
+        if newCount >= updateBatchSize || progress.downloadedBlobs == progress.totalBlobs {
+            // Reset counter and update Live Activity
+            lastUpdateCounts[accountDid] = 0
+            await updateLiveActivityIfNeeded(accountDid: accountDid, progress: progress)
+        }
+        #endif
+    }
+    
+    #if os(iOS)
+    private func updateLiveActivityIfNeeded(accountDid: String, progress: DownloadProgress) async {
+        guard let activity = liveActivities[accountDid] else { return }
+        
+        let progressPercent = Double(progress.downloadedBlobs) / Double(progress.totalBlobs)
+        let status: DownloadActivityAttributes.ContentState.DownloadStatus = 
+            progress.downloadedBlobs == progress.totalBlobs ? .completed : .downloading
+        
+        let updatedState = DownloadActivityAttributes.ContentState(
+            progress: progressPercent,
+            downloadedBlobs: progress.downloadedBlobs,
+            totalBlobs: progress.totalBlobs,
+            accountHandle: activity.attributes.accountHandle,
+            isPaused: false,
+            status: status
+        )
+        
+        await activity.update(using: updatedState)
+        print("[BackgroundTracker] Updated activity for \(accountDid) - Blobs: \(progress.downloadedBlobs)/\(progress.totalBlobs)")
+        
+        // If completed, end the activity after a delay
+        if status == .completed {
+            Task {
+                try? await Task.sleep(nanoseconds: 3_000_000_000) // 3 seconds
+                await activity.end(dismissalPolicy: .immediate)
+                liveActivities.removeValue(forKey: accountDid)
+                downloadProgress.removeValue(forKey: accountDid)
+                lastUpdateCounts.removeValue(forKey: accountDid)
+            }
+        }
+    }
+    #endif
+    
+    func getProgress(for accountDid: String) -> (downloaded: Int, total: Int)? {
+        guard let progress = downloadProgress[accountDid] else { return nil }
+        return (progress.downloadedBlobs, progress.totalBlobs)
+    }
+    
+    func cleanup(for accountDid: String) {
+        downloadProgress.removeValue(forKey: accountDid)
+        #if os(iOS)
+        liveActivities.removeValue(forKey: accountDid)
+        lastUpdateCounts.removeValue(forKey: accountDid)
+        #endif
+    }
+}

AtProtoBackup/BlobDownloader.swift

···
   case failed(error: Error)
 }
 
+// Structure to hold download result
+struct DownloadResult {
+  let tempURL: URL
+  let response: URLResponse?
+}
+
+// Async semaphore for concurrency control
+actor AsyncSemaphore {
+    private var value: Int
+    private var waiters: [CheckedContinuation<Void, Never>] = []
+    
+    init(value: Int) {
+        self.value = value
+    }
+    
+    func wait() async {
+        if value > 0 {
+            value -= 1
+            return
+        }
+        
+        await withCheckedContinuation { continuation in
+            waiters.append(continuation)
+        }
+    }
+    
+    func signal() {
+        if let waiter = waiters.first {
+            waiters.removeFirst()
+            waiter.resume()
+        } else {
+            value += 1
+        }
+    }
+}
+
+// Delegate handler for background downloads
+class BlobDownloadDelegate: NSObject, URLSessionDownloadDelegate {
+  private var downloadCompletions: [URLSessionDownloadTask: CheckedContinuation<DownloadResult, Error>] = [:]
+  private var taskResponses: [URLSessionDownloadTask: URLResponse] = [:]
+  private var taskAccountDids: [URLSessionDownloadTask: String] = [:]
+  private let completionQueue = DispatchQueue(label: "com.app.atproto.download-completions")
+  
+  func addCompletion(_ continuation: CheckedContinuation<DownloadResult, Error>, for task: URLSessionDownloadTask, accountDid: String? = nil) {
+    completionQueue.sync {
+      downloadCompletions[task] = continuation
+      if let accountDid = accountDid {
+        taskAccountDids[task] = accountDid
+      }
+    }
+  }
+  
+  func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+    completionQueue.sync {
+      if let continuation = downloadCompletions[downloadTask] {
+        // Move file to temporary location to prevent deletion
+        let tempDir = FileManager.default.temporaryDirectory
+        let tempURL = tempDir.appendingPathComponent(UUID().uuidString)
+        do {
+          try FileManager.default.moveItem(at: location, to: tempURL)
+          let response = taskResponses[downloadTask] ?? downloadTask.response
+          let result = DownloadResult(tempURL: tempURL, response: response)
+          continuation.resume(returning: result)
+          
+          // Update background tracker if this is a blob download
+          if let accountDid = taskAccountDids[downloadTask] {
+            Task {
+              await BackgroundDownloadTracker.shared.incrementProgress(for: accountDid)
+            }
+          }
+        } catch {
+          continuation.resume(throwing: error)
+        }
+        downloadCompletions.removeValue(forKey: downloadTask)
+        taskResponses.removeValue(forKey: downloadTask)
+        taskAccountDids.removeValue(forKey: downloadTask)
+      }
+    }
+  }
+  
+  func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
+    // Store response for download tasks
+    if let downloadTask = dataTask as? URLSessionDownloadTask {
+      completionQueue.sync {
+        taskResponses[downloadTask] = response
+      }
+    }
+    completionHandler(.allow)
+  }
+  
+  func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+    completionQueue.sync {
+      if let downloadTask = task as? URLSessionDownloadTask,
+         let continuation = downloadCompletions[downloadTask] {
+        if let error = error {
+          continuation.resume(throwing: error)
+          downloadCompletions.removeValue(forKey: downloadTask)
+          taskResponses.removeValue(forKey: downloadTask)
+          taskAccountDids.removeValue(forKey: downloadTask)
+        }
+        // If no error, success is handled in didFinishDownloadingTo
+      }
+    }
+  }
+  
+  func urlSessionDidFinishEvents(forBackgroundURLSession session: URLSession) {
+    // Handle background session completion
+    // You might want to post a notification here if needed
+  }
+}
+
 public actor BlobDownloader {
-  private var maxConcurrentDownloads: Int = 1
+  private var maxConcurrentDownloads: Int = 5
   private var activeTasks = 0
   private var continuation: CheckedContinuation<Void, Never>?
   //    private var atProtocolManger: AtProtocolManager
···
   private var activeDownloadTasks: Set<Task<URL?, Error>> = []
   private var currentDownloadTask: Task<[URL], Error>?
   
+  // Delegate instance
+  private let sessionDelegate = BlobDownloadDelegate()
+  
+  // Stable session identifier for background downloads
+  private static let backgroundSessionIdentifier = "com.app.atproto.backup.downloader"
+  
+  private lazy var backgroundSession: URLSession = {
+    let config = URLSessionConfiguration.background(
+      withIdentifier: Self.backgroundSessionIdentifier
+    )
+    config.isDiscretionary = false
+    config.sessionSendsLaunchEvents = true
+    config.allowsCellularAccess = true // For critical data
+    return URLSession(configuration: config, delegate: sessionDelegate, delegateQueue: nil)
+  }()
+  
+  // Initialize and restore any pending background downloads
+  public init() {
+    // Force creation of the session to reconnect with any existing downloads
+    _ = backgroundSession
+  }
+  
+  // Static method to handle background session events (call from AppDelegate)
+  public static func handleEventsForBackgroundURLSession(
+    identifier: String,
+    completionHandler: @escaping () -> Void
+  ) {
+    if identifier == backgroundSessionIdentifier {
+      // Store the completion handler to call when all tasks complete
+      // This would typically be handled in the delegate's urlSessionDidFinishEvents method
+      completionHandler()
+    }
+  }
   // Progress tracking
   //    private var progressContinuation: AsyncStream<DownloadProgress>.Continuation?
   
···
     }
   }
   
+  // Background-optimized download method that enqueues all tasks immediately
+  func downloadBlobsBackground(
+    repo: String,
+    pdsURL: String,
+    cids: [String],
+    saveLocationBookmark: Data? = nil,
+    maxConcurrent: Int = 5,
+    progressHandler: ((Int, Int) -> Void)? = nil
+  ) async throws -> [URL] {
+    // Resolve save location
+    var saveLocation: URL
+    if let override = saveLocationBookmark {
+      var isStale = false
+      guard
+        let saveUrl = try? URL(
+          resolvingBookmarkData: override,
+          options: .withoutUI,
+          relativeTo: nil,
+          bookmarkDataIsStale: &isStale
+        )
+      else {
+        throw GenericIntentError.message("Failed to resolve bookmark data")
+      }
+      saveLocation = saveUrl
+    } else {
+      let tempDirectory = FileManager.default.temporaryDirectory
+      saveLocation = tempDirectory.appendingPathComponent(repo)
+      
+      do {
+        try FileManager.default.createDirectory(
+          at: saveLocation, withIntermediateDirectories: true, attributes: nil)
+      } catch CocoaError.fileWriteFileExists {
+        print("Folder already exists at: \(saveLocation.path)")
+      } catch {
+        throw error
+      }
+    }
+    
+    print("Starting background download of \(cids.count) blobs with max \(maxConcurrent) concurrent")
+    
+    // Create all download tasks immediately so they continue in background
+    var results: [String: URL] = [:]
+    let resultsLock = NSLock()
+    
+    // Semaphore to limit concurrent downloads
+    let semaphore = AsyncSemaphore(value: maxConcurrent)
+    
+    // Use a TaskGroup to wait for all downloads
+    try await withThrowingTaskGroup(of: (String, URL)?.self) { group in
+      for cid in cids {
+        group.addTask { [weak self] in
+          guard let self = self else { return nil }
+          
+          // Wait for semaphore before starting download
+          await semaphore.wait()
+          
+          do {
+            let url = try await self.getBlob(
+              from: repo,
+              cid: cid,
+              fileManager: FileManager.default,
+              saveLocation: saveLocation,
+              pdsURL: pdsURL
+            )
+            await semaphore.signal()
+            return (cid, url)
+          } catch {
+            print("Failed to download blob \(cid): \(error)")
+            await semaphore.signal()
+            return nil
+          }
+        }
+      }
+      
+      var downloadedCount = 0
+      for try await result in group {
+        if let (cid, url) = result {
+          resultsLock.lock()
+          results[cid] = url
+          downloadedCount += 1
+          resultsLock.unlock()
+          
+          progressHandler?(downloadedCount, cids.count)
+        }
+      }
+    }
+    
+    // Return URLs in original CID order
+    return cids.compactMap { results[$0] }
+  }
+  
   // Modified downloadBlobs method with proper cleanup
   func downloadBlobs(
+    repo: String,
+    pdsURL: String,
+    cids: [String],
+    saveLocationBookmark: Data? = nil,
+    maxConcurrentDownloads: Int = 1,
+    progressHandler: ((Int, Int) -> Void)? = nil
+  ) async throws -> [URL] {
+    // Use background-optimized method for better suspension handling
+    return try await downloadBlobsBackground(
+      repo: repo,
+      pdsURL: pdsURL,
+      cids: cids,
+      saveLocationBookmark: saveLocationBookmark,
+      maxConcurrent: maxConcurrentDownloads,
+      progressHandler: progressHandler
+    )
+  }
+  
+  // Legacy chunked download method (kept for reference)
+  func downloadBlobsChunked(
     repo: String,
     pdsURL: String,
     cids: [String],
···
     resourceURL: URL,
     fileManager: FileManager,
     saveLocation: URL,
-    fileName: String
+    fileName: String,
+    accountDid: String? = nil
   ) async throws -> URL {
     try Task.checkCancellation()
     
···
     request.setValue("*/*", forHTTPHeaderField: "Accept")
     request.timeoutInterval = 30
     
-    // Download to file instead of memory
-    let (tempURL, response) = try await URLSession.shared.download(for: request)
+    // Create download task and use continuation
+    let result = try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<DownloadResult, Error>) in
+      let downloadTask = self.backgroundSession.downloadTask(with: request)
+      self.sessionDelegate.addCompletion(continuation, for: downloadTask, accountDid: accountDid)
+      downloadTask.resume()
+    }
+    
+    let tempURL = result.tempURL
+    let response = result.response
     
     if let httpResponse = response as? HTTPURLResponse {
       switch httpResponse.statusCode {
···
         let mimeType = httpResponse.value(forHTTPHeaderField: "Content-Type") ?? ""
         let ending = fileExtension(fromMimeType: mimeType).map { ".\($0)" } ?? ""
         let newLocation = saveLocation.appendingPathComponent("\(fileName)\(ending)")
-        try fileManager.moveItem(
-          at: tempURL, to: newLocation)
+        try fileManager.moveItem(at: tempURL, to: newLocation)
         return newLocation
       case 400:
-        let (data, _) = try await URLSession.shared.data(for: request)
-        
-        let errorResponse = try JSONDecoder().decode(
-          ATHTTPResponseError.self, from: data)
-        throw BlobDownloadError.apiError(error: errorResponse)
+        // For 400 errors, we'd need to handle differently since background downloads
+        // don't give us the response body. Just throw the error.
+        try? FileManager.default.removeItem(at: tempURL)
+        throw BlobDownloadError.httpError(statusCode: 400)
         
       default:
         try? FileManager.default.removeItem(at: tempURL)
···
           statusCode: httpResponse.statusCode)
       }
     }
-    throw BlobDownloadError.unknownError
-    //    guard let httpResponse = response as? HTTPURLResponse,
-    //        (200...299).contains(httpResponse.statusCode)
-    //    else {
-    //        try? FileManager.default.removeItem(at: tempURL)
-    //        throw BlobDownloadError.httpError(
-    //            statusCode: (response as? HTTPURLResponse)?.statusCode ?? 0)
-    //    }
     
+    // If no response info, assume success and process based on content
+    let mimeType = "application/octet-stream" // Default
+    let ending = fileExtension(fromMimeType: mimeType).map { ".\($0)" } ?? ""
+    let newLocation = saveLocation.appendingPathComponent("\(fileName)\(ending)")
+    try fileManager.moveItem(at: tempURL, to: newLocation)
+    return newLocation
   }
   
   public func getBlob(
···
     saveLocation: URL,
     pdsURL: String? = nil
   ) async throws -> URL {
+    // Check if blob already exists with any extension
+    let fileEnumerator = fileManager.enumerator(
+      at: saveLocation,
+      includingPropertiesForKeys: [.isRegularFileKey],
+      options: [.skipsHiddenFiles, .skipsSubdirectoryDescendants]
+    )
+    
+    if let fileEnumerator = fileEnumerator {
+      for case let fileURL as URL in fileEnumerator {
+        let fileName = fileURL.deletingPathExtension().lastPathComponent
+        if fileName == cid {
+          print("Blob \(cid) already exists at \(fileURL.path), skipping download")
+          
+          // Update progress tracker for existing file
+//          if let accountDid = accountDID {
+            Task {
+              await BackgroundDownloadTracker.shared.incrementProgress(for: accountDID)
+            }
+//          }
+          
+          return fileURL
+        }
+      }
+    }
+    
     let baseUrl = pdsURL ?? "https://bsky.network"
     
     // Construct URL with query parameters
···
     }
     
     return try await streamBlobToDisk(
-      resourceURL: url, fileManager: fileManager, saveLocation: saveLocation, fileName: cid)
+      resourceURL: url, fileManager: fileManager, saveLocation: saveLocation, fileName: cid, accountDid: accountDID)
   }
   
   public func getCar(
···
   ) async throws -> URL {
     
     let baseUrl = pdsURL ?? "https://bsky.network"
-    // Only ever one file being downloaded
-    self.maxConcurrentDownloads = 1
-    // Construct URL with query parameters
     guard var urlComponents = URLComponents(string: "\(baseUrl)/xrpc/com.atproto.sync.getRepo")
     else {
       throw BlobDownloadError.invalidURL

AtProtoBackup/ContentView.swift

···
 
 #Preview {
   ContentView()
-    .modelContainer(for: Account.self, inMemory: true)
+    .modelContainer(for: Account.self, inMemory: false)
 }

AtProtoBackup/DownloadActivityAttributes.swift

···
+#if os(iOS)
 import ActivityKit
+#endif
 import Foundation
 
+#if os(iOS)
 struct DownloadActivityAttributes: ActivityAttributes {
     public struct ContentState: Codable, Hashable {
         var progress: Double
···
     
     var accountDid: String
     var accountHandle: String
-}
+}
+#else
+struct DownloadActivityAttributes {
+    public struct ContentState: Codable, Hashable {
+        var progress: Double
+        var downloadedBlobs: Int
+        var totalBlobs: Int?
+        var accountHandle: String
+        var isPaused: Bool
+        var status: DownloadStatus
+        
+        enum DownloadStatus: String, Codable {
+            case fetchingData = "Fetching repository data..."
+            case downloading = "Downloading"
+            case paused = "Paused"
+            case completed = "Completed"
+        }
+    }
+    
+    var accountDid: String
+    var accountHandle: String
+}
+#endif

AtProtoBackup/DownloadManager.swift

···
 import SwiftUI
 import Combine
 import ATProtoKit
+#if os(iOS)
 import ActivityKit
+#endif
 
 struct DownloadInfo: Identifiable {
   let id = UUID()
···
 class DownloadManager: ObservableObject {
   @Published private var downloads: [String: DownloadInfo] = [:]
   private let blobDownloader = BlobDownloader()
+  #if os(iOS)
   private var liveActivities: [String: Activity<DownloadActivityAttributes>] = [:]
+  #endif
   
   func getDownload(for account: Account) -> DownloadInfo? {
     downloads[account.did]
···
       downloads[account.did]?.progress = downloads[account.did]?.progress ?? 0
     }
 
+    #if os(iOS)
     // Start Live Activity
     startLiveActivity(for: account)
+    #endif
     
     Task {
       await MainActor.run {
         downloads[accountDid]?.isDownloading = true
       }
       
+      #if os(iOS)
       // Update Live Activity to fetching state
       updateLiveActivity(for: accountDid, status: .fetchingData, progress: 0, downloadedBlobs: 0, totalBlobs: nil, isPaused: false)
+      #endif
       
       do {
         let tempDirectory = FileManager.default.temporaryDirectory
···
           downloads[accountDid]?.progress = 0  // Reset progress for blob downloads
         }
         
+        #if os(iOS)
         // Update Live Activity to downloading state
         updateLiveActivity(for: accountDid, status: .downloading, progress: 0, downloadedBlobs: 0, totalBlobs: totalCount, isPaused: false)
         
+        // Register with background tracker
+        await BackgroundDownloadTracker.shared.registerDownload(accountDid: accountDid, totalBlobs: totalCount)
+        if let activity = liveActivities[accountDid] {
+            await BackgroundDownloadTracker.shared.registerLiveActivity(activity, for: accountDid)
+        }
+        #endif
+        
 //        guard let saveUrl = saveLocation.fileURL else {
 //          throw GenericIntentError.message(
 //            "Was not able to get a valid url for the save location")
···
             if let totalBlobs = self?.downloads[accountDid]?.totalBlobs {
               let progress = Double(downloaded) / Double(totalBlobs)
               self?.downloads[accountDid]?.progress = progress
-              // Update Live Activity progress
-              self?.updateLiveActivity(for: accountDid, status: .downloading, progress: progress, downloadedBlobs: downloaded, totalBlobs: totalBlobs, isPaused: false)
+              // Live Activity updates are now handled by BackgroundDownloadTracker
             }
           }
         }
···
           downloads[accountDid]?.isDownloading = false
         }
         
-        // Update Live Activity to completed
-        updateLiveActivity(for: accountDid, status: .completed, progress: 1.0, downloadedBlobs: totalCount, totalBlobs: totalCount, isPaused: false)
-        
-        // End Live Activity after a delay
-        Task {
-          try await Task.sleep(nanoseconds: 3_000_000_000) // 3 seconds
-          endLiveActivity(for: accountDid)
-        }
+        #if os(iOS)
+        // Final update is handled by BackgroundDownloadTracker when last blob completes
+        // Clean up the tracker
+        await BackgroundDownloadTracker.shared.cleanup(for: accountDid)
+        #endif
         
       } catch {
         print("Download error: \(error)")
···
   
   // MARK: - Live Activity Management
   
+  #if os(iOS)
   private func startLiveActivity(for account: Account) {
     print("[LiveActivity] Checking if activities are enabled...")
     guard ActivityAuthorizationInfo().areActivitiesEnabled else { 
···
       liveActivities.removeValue(forKey: accountDid)
     }
   }
+  #endif
 }

AtProtoBackup/Info.plist

···
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-	<key>NSSupportsLiveActivities</key>
-	<true/>
 	<key>UIBackgroundModes</key>
 	<array>
 		<string>remote-notification</string>
+		<string>fetch</string>
+		<string>processing</string>
 	</array>
 </dict>
 </plist>

AtProtoBackup/LiveActivityManager.swift

···
+#if os(iOS)
 import ActivityKit
+#endif
 import Foundation
 
 class LiveActivityManager {
     static let shared = LiveActivityManager()
     
     private init() {
+        #if os(iOS)
         // Check Activity permissions on init
         Task {
             await checkActivityPermissions()
         }
+        #endif
     }
     
+    #if os(iOS)
     func checkActivityPermissions() async {
         let authorizationInfo = ActivityAuthorizationInfo()
         
···
         // but we can check if they're enabled
         await checkActivityPermissions()
     }
+    #endif
 }

WidgetExtension/DownloadActivityAttributes.swift

···
+#if os(iOS)
 import ActivityKit
 import Foundation
 
···
     
     var accountDid: String
     var accountHandle: String
-}
+}
+#endif

WidgetExtension/DownloadLiveActivityView.swift

···
+#if os(iOS)
 import ActivityKit
 import SwiftUI
 import WidgetKit
···
                 .foregroundColor(.green)
         }
     }
-}
+}
+#endif

WidgetExtension/WidgetExtensionBundle.swift

···
 //
 //  Created by Corey Alexander on 8/28/25.
 //
-
+#if os(iOS)
 import WidgetKit
 import SwiftUI
 
···
         DownloadActivityWidget()
     }
 }
+#endif