use @main in Xcode 12

Question

I want to run this code on iOS 13 and above how should I fix this error? I want to make this code could run on iOS 13 too.

@available(iOS 14.0, *)
@main

struct WeatherProApp: App {
  @Environment(\.scenePhase) private var scenePhase
  @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

  
  var body: some Scene {
    WindowGroup{
      let fetcher = WeatherFetcher()
      let viewModel = WeeklyWeatherViewModel(weatherFethcer: fetcher)
      WeeklyWeatherView(viewModel: viewModel)
    }
    .onChange(of: scenePhase) { (newScenePhase) in
      switch newScenePhase {
      case .active:
        print("scene is now active!")
      case .inactive:
        print("scene is now inactive!")
      case .background:
        print("scene is now in the background!")
      @unknown default:
        print("Apple must have added something new!")
      }
    }
  }
}

but it shows me this error

Answer 1

Following @the.blaggy answer, here is how I managed to run my project on iOS 13:

1. Create a SceneDelegate if you do not have one

SceneDelegate.swift

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        let contentView = ContentView()

        // Use a UIHostingController as window root view controller.
        if let windowScene = scene as? UIWindowScene {
            let window = UIWindow(windowScene: windowScene)
            window.rootViewController = UIHostingController(rootView: contentView)
            self.window = window
            window.makeKeyAndVisible()
        }
    }
}

2. Open your info.plist as Source Code and add those lines :

Info.plist

   <key>UIApplicationSceneManifest</key>
       <dict>
           <key>UIApplicationSupportsMultipleScenes</key>
           <false/>
           <key>UISceneConfigurations</key>
           <dict>
           <key>UIWindowSceneSessionRoleApplication</key>
           <array>
               <dict>
                   <key>UISceneConfigurationName</key>
                   <string>Default Configuration</string>
                   <key>UISceneDelegateClassName</key>
                   <string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
               </dict>
           </array>
       </dict>
   </dict>

3. Add this in your WeatherProApp.swift

WeatherProApp.swift

    @main
    struct WeatherProAppWrapper {
        static func main() {
            if #available(iOS 14.0, *) {
                WeatherProApp.main()
            }
            else {
                UIApplicationMain(CommandLine.argc, CommandLine.unsafeArgv, nil, NSStringFromClass(SceneDelegate.self))
            }
        }
    }

Answer 2

Actually you can use the @main attribute in pre iOS 14 but you need an alternative AppDelegate and SceneDelegate (you can copy these two delegate classes from iOS 13 Xcode projects) and you have to do some extra wrapping.

First you have to apply the @main attribute in the following way to a struct with a main function which decides depending on the iOS version whether to use the WeatherProApp struct or the AppDelegate class to launch:

@main
struct WeatherProAppWrapper {
    static func main() {
        if #available(iOS 14.0, *) {
            WeatherProApp.main()
        }
        else {
            UIApplicationMain(CommandLine.argc, CommandLine.unsafeArgv, nil, NSStringFromClass(AppDelegate.self))
        }
    }
}

Afterwards you can use the shown implementation from your question, just remove the @main attribute, only use @available(iOS 14.0, *). E.g.:

@available(iOS 14.0, *)
struct WeatherProApp: App {
    var body: some Scene {
        WindowGroup{
            ContentView()
        }
    }
}

I'm not sure how familiar you're with UIKit but you have to do the same setup you did in your WindowGroup in the SceneDelegate class too.

Answer 3

This might depend on other project code, but the following tested as works (Xcode 12b), so might be helpful.

The idea is to hide one wrapper inside another structure with availability checker:

@available(iOS 14.0, macOS 10.16, *)
struct Testing_SwiftUI2AppHolder {
    @main
    struct Testing_SwiftUI2App: App {

        var body: some Scene {
            WindowGroup {
                ContentView()
            }
        }
    }
}

Answer 4

If you really need it, just change @main to @UIApplicationMain, it should do the trick.

Answer 5

Combining answers by @the.blaggy and @Ugo Marinelli, I made it work by modifying my AppDelegate, without having to create a new SceneDelegate:

class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?

    func application(
        _: UIApplication,
        didFinishLaunchingWithOptions _: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        let window = UIWindow(frame: UIScreen.main.bounds)

        window.rootViewController = UIHostingController(
            rootView: ContentView()
        )
        self.window = window
        window.makeKeyAndVisible()
        return true
    }
}

I also wrapped my main struct like what @the.blaggy did.

Answer 6

The answer from @the.blaggy is really helpful, thanks a lot for the main idea. I just had no AppDelegate and SceneDelegate to copy these two delegate classes from iOS 13 Xcode projects. I just need to support iOS13+ and macOS using same new SwiftUI views instead of creating old UIKit and AppKit ones.

AppDelegate allows us to use configurationForConnecting directly in Swift instead of using plist file.

And @UIApplicationDelegateAdaptor allows us to use same AppDelegate for iOS14+.

So, I've wrote MainAppWrapper, MainApp, AppDelegate, SceneDelegate in one file.

The file can be used as a start template for any SwiftUI project to run same SwiftUI's ContentView() under any OS: iOS13, iOS14+, macOS.

Just replace a whole @main struct onto this code and you will see same ContentView() under all OS.

import SwiftUI

@main
struct MainAppWrapper {
    static func main() {
        if #available(iOS 14.0, *) {
            MainApp.main()
        }
        else {
            #if os(iOS)
            UIApplicationMain(CommandLine.argc, CommandLine.unsafeArgv, nil,
                NSStringFromClass(AppDelegate.self))
            #endif
        }
    }
}

@available(iOS 14.0, *)
struct MainApp: App {
    #if os(iOS)
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
    #endif

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

#if os(iOS)
class AppDelegate: NSObject, UIApplicationDelegate, ObservableObject {
    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        let config = UISceneConfiguration(name: nil, sessionRole: connectingSceneSession.role)
        config.delegateClass = SceneDelegate.self
        return config
    }
}

class SceneDelegate: NSObject, UIWindowSceneDelegate, ObservableObject {
    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        if #unavailable(iOS 14.0) {
          let contentView = ContentView()

          // Use a UIHostingController as window root view controller.
          if let windowScene = scene as? UIWindowScene {
              let window = UIWindow(windowScene: windowScene)
              window.rootViewController = UIHostingController(rootView: contentView)
              self.window = window
              window.makeKeyAndVisible()
          }
        }
    }
}
#endif