How can I ensure overridden UIActivity methods run on @MainActor in Swift 6?

When overriding methods from a UIKit class such as UIActivity, you cannot simply add an actor isolation annotation (like @MainActor) to just the override if the original definition isn’t isolated that way. In other words, changing the actor context of an override independently isn’t allowed.

The best approach in your case is to mark the entire subclass as @MainActor, which “lifts” all of its methods and properties onto the main actor. This ensures that every method in your SafariActivity will run on the main thread. For example:

SWIFTCopied
import Foundation
import UIKit

@MainActor
public final class SafariActivity: UIActivity {

    var url: URL?
    
    // MARK: - UIActivity Implementation
    
    public override var activityType: UIActivity.ActivityType {
        .openInSafari
    }
    
    public override var activityTitle: String? {
        "Open in Safari"
    }
    
    public override var activityImage: UIImage? {
        UIImage(systemName: "safari")?.applyingSymbolConfiguration(.init(scale: .large))
    }
    
    public override func canPerform(withActivityItems activityItems: [Any]) -> Bool {
        activityItems.contains { item in
            if let url = item as? URL {
                return UIApplication.shared.canOpenURL(url)
            }
            return false
        }
    }
    
    public override func prepare(withActivityItems activityItems: [Any]) {
        url = activityItems.first { item in
            if let url = item as? URL {
                return UIApplication.shared.canOpenURL(url)
            }
            return false
        } as? URL
    }
    
    public override func perform() {
        if let url = url {
            UIApplication.shared.open(url)
        }
        self.activityDidFinish(true)
    }
}

extension UIActivity.ActivityType {
    static let openInSafari = UIActivity.ActivityType(rawValue: "openInSafari")
}

extension UIActivity {
    @MainActor 
    public static let openInSafari = SafariActivity()
}

Explanation

• Annotating the class with @MainActor:
  By adding @MainActor to the SafariActivity class declaration, all its methods run on the main thread. This resolves the errors around accessing UIApplication.shared, which is marked as main actor–only.

• Why not annotate individual methods?
  You might consider annotating each method (e.g., adding @MainActor above each override). However, UIKit’s UIActivity methods aren’t declared as @MainActor on the base class; hence, overriding them with a stricter isolation level is not allowed. The only proper route is to annotate the whole class.

• Adapting to Swift Concurrency:
  With Swift 6 and its concurrency model, ensuring UIKit code runs on the main thread is critical. Wrapping the entire class in @MainActor is an efficient way to meet that requirement without altering the method signatures individually.

This approach should resolve the errors you’re encountering while keeping your implementation compliant with Swift 6’s concurrency rules.