Redirecting after task w/ Await completes

In a view, I want to wait for a series of async calls to finish loading, then redirect to another screen. Unfortunately, I see the code running in the back (The JSON data gets loaded) but once it completes it does not redirect to the new view.

Here is my view:

struct loadingView: View {
    @ObservedObject var dataLoader: DataLoader = DataLoader()
    @State var isLoaded: Bool = false

    var body: some View {
        VStack {
           Text("Loading \(isLoaded)")
        }
    }
    .task {
        await self.dataloader.loadJSONData(isLoaded: $isLoaded)
        MainScreen()
    }
}

...and the DataLoader class:

@MainActor DataLoader: NSObject, ObservableObject {
    func loadJSONData(isLoaded: Binding<Bool>) {
        await doLoadData()
        isLoaded.wrappedValue = True
    }

    func doLoadData() async {
        /* do data load */
        /* This code works */
    }
}

"Redirecting" here doesn't really make sense. Do you really want the user to be able to navigate back to the loading screen? Perhaps you're thinking of this like a web page, but SwiftUI is nothing like that. What you really want to do is display one thing when loading, and a different thing when loaded. That's just if, not "redirection."

Instead, consider the following pattern. Create this kind of LoadingView (extracted from some personal code of mine):

struct LoadingView<Content: View, Model>: View {
    enum LoadState {
        case loading
        case loaded(Model)
        case error(Error)
    }

    @ViewBuilder let content: (Model) -> Content
    let loader: () async throws -> Model

    @State var loadState = LoadState.loading

    var body: some View {
        ZStack {
            Color.white
            switch loadState {
            case .loading: Text("Loading")
            case .loaded(let model): content(model)
            case .error(let error): Text(verbatim: "Error: \(error)")
            }
        }
        .task {
            do {
                loadState = .loaded(try await loader())
            } catch {
                loadState = .error(error)
            }
        }
    }
}

It require no redirection. It just displays different things when in different states (obviously the Text view can be replaced by something more interesting).

Then to use this, embed it in another View. In my personal code, that includes a view like this:

struct DailyView: View {
    var body: some View {
        LoadingView() { model in
            LoadedDailyView(model: model)
        } loader: {
            try await DailyModel()
        }
    }
}

Then LoadedDailyView is the "real" view. It is handled a fully populated model that is created by DailyModel.init (a throwing, async init).

You could try this approach, using NavigationStack and NavigationPath to Redirecting after task w/ Await completes.

Here is the code I use to test my answer:

struct ContentView: View {
var body: some View {
loadingView()
}
}
@MainActor
class DataLoader: NSObject, ObservableObject {
func loadJSONData() async {
await doLoadData()
// for testing, wait for 1 second
try? await Task.sleep(nanoseconds: 1 * 1_000_000_000)
}
func doLoadData() async {
/* do data load */
/* This code works */
}
}
struct loadingView: View {
@StateObject var dataLoader = DataLoader()
@State private var navPath = NavigationPath()
var body: some View {
NavigationStack(path: $navPath) {
VStack (spacing: 44) {
Text("Loading....")
}
.navigationDestination(for: Bool.self) { _ in
MainScreen()
}
}
.task {
await dataLoader.loadJSONData()
navPath.append(true)
}
}
}
struct MainScreen: View {
var body: some View {
Text("---> MainScreen here <---")
}
}

If you need ios 15 or earlier, then use NavigationView:

struct loadingView: View {
@StateObject var dataLoader = DataLoader()
@State var isLoaded: Bool?
var body: some View {
NavigationView {
VStack {
Text(isLoaded == nil ? "Loading..." : "Finished loading")
NavigationLink("", destination: MainScreen(), tag: true, selection: $isLoaded)
}
}.navigationViewStyle(.stack)
.task {
await dataLoader.loadJSONData()
isLoaded = true
}
}
}

If your loadingView has the only purpose of showing the "loading" message, then
display the MainScreen after the data is loaded, you could use the following approach using a simple swicth:

struct loadingView: View {
@StateObject var dataLoader = DataLoader()
@State private var isLoaded = false
var body: some View {
VStack {
if isLoaded {
MainScreen()
} else {
ProgressView("Loading")
}
}
.task {
await dataLoader.loadJSONData()
isLoaded = true
}
}
}

Use @StateObject instead of @ObservedObject. Use @Published instead of trying to pass a binding to the object (that is a mistake because a binding is just a pair of get and set closures that will expire if LoadingView is re-init), use Group with an if to conditionally show a View e.g.

struct LoadingView: View {
@StateObject var dataLoader: DataLoader = DataLoader()
var body: some View {
Group {
if dataLoader.isLoaded {
LoadedView(data: dataLoader.data)
} else {
Text("Loading...")
}
}
.task {
await dataloader.loadJSONData()
}
}

The DataLoader should not be @MainActor because you want it to run on a background thread. Use @MainActor instead on a sub-task once the async work has finished e.g.

class DataLoader: ObservableObject {
@Published var isLoaded = false
@Published var data: [Data] = []
func loadJSONData async {
let d = await doLoadData()
Task { @MainActor in
isLoaded = true
data = d
}
}
func doLoadData() async {
/* do data load */
/* This code works */
}
}

This pattern is shown in Apple's tutorial here, PandaCollectionFetcher.swift copied below:

import SwiftUI
class PandaCollectionFetcher: ObservableObject {
@Published var imageData = PandaCollection(sample: [Panda.defaultPanda])
@Published var currentPanda = Panda.defaultPanda
let urlString = "http://playgrounds-cdn.apple.com/assets/pandaData.json"
enum FetchError: Error {
case badRequest
case badJSON
}
func fetchData() async 
throws  {
guard let url = URL(string: urlString) else { return }
let (data, response) = try await URLSession.shared.data(for: URLRequest(url: url))
guard (response as? HTTPURLResponse)?.statusCode == 200 else { throw FetchError.badRequest }
Task { @MainActor in
imageData = try JSONDecoder().decode(PandaCollection.self, from: data)
}
}
}