Forgive me this iOS only question, but I really don't find the correct solution. 🙈 How can I make that my SwiftUI task runs on the background?

task

is always on the main thread.

Task.detached

starts a new task on another thread. The problem is

Task.detached()

runs to completion even is task is cancelled because the cancellation is not propagated. Can some expert please enlight me how to correctly do that?

.task {

      Task.detached {

        guard image == nil else { return }

        image = await imageLoader.loadThumbnailImage(photoUri: photo.uri)
      }
    }

By reading the docs only: What about

.task(priority: .background) {
    Task {
    }
}

That still runs on the main actor unfortunately.

I thought, they do. But

Task.detached

is

GlobalScope

, which doesn't inherit cancelation too:

suspend fun a() {
     while (true) {
        delay(1.seconds)
        println("Still running")
    }
}
    
@OptIn(DelicateCoroutinesApi::class)
@Test
fun b(): Unit = runBlocking {
    withTimeout(5.seconds) {
        GlobalScope.launch {
            a()
        }
    }
    delay(10.seconds)
}

Yeah, I'm so confused. Apple changes API all the time and a lot of solutions for that are outdated. 🤷‍♂️

not similar, but this works: `actor`:

import SwiftUI

struct ContentView: View {
    let a = A()
    
    var body: some View {
        Text("Hello, world!")
            .padding()
            .task(priority: .background) {
                print("Start Thread")
                await a.a()
            }
    }
}


actor A {
    func a() async {
        Task {
            print("Start Sleeping")
            try await Task.sleep(nanoseconds: 50_000_000_000)
        }
    }
}

Thank you. 🙏 I guess I need to look up again the whole "actor" mechanics. 😅 Changing my ImageLoaderImpl from "class" to "actor" according to your sample does the trick.

Keep in mind, `actor`s handles

async

calls sequentiell!

So no concurrent image loadings at the same time?

Nice 😄