Set up your app

import SwiftUI
import UIKit
import UserNotifications

@main
struct AcmeApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

    var body: some Scene {
        WindowGroup { Text("Acme") }
    }
}

final class AppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {
    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
        UNUserNotificationCenter.current().delegate = self
        Task {
            // Asks once; on later launches it answers straight away with the person's choice.
            let granted = (try? await UNUserNotificationCenter.current()
                .requestAuthorization(options: [.alert, .sound, .badge])) ?? false
            // Register on every launch: Apple can change the token.
            if granted { application.registerForRemoteNotifications() }
        }
        return true
    }

    func application(_ application: UIApplication,
                     didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        // HonkIO takes the token as hex text. Don't assume a fixed length.
        let token = deviceToken.map { String(format: "%02x", $0) }.joined()
        Task { await sendTokenToBackend(token) }
    }

    func application(_ application: UIApplication,
                     didFailToRegisterForRemoteNotificationsWithError error: Error) {
        // Most often the Push Notifications capability is missing from the target.
        print("Push registration failed: \(error)")
    }

    // Show a push that arrives while the app is open, instead of dropping it.
    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter,
                                            willPresent notification: UNNotification) async -> UNNotificationPresentationOptions {
        [.banner, .sound, .badge]
    }
}

/// Your own endpoint, called as the signed-in person. Your backend then calls PUT /v1/push/devices.
func sendTokenToBackend(_ token: String) async {
    #if DEBUG
    let environment = "sandbox"     // a build you run from Xcode
    #else
    let environment = "production"  // TestFlight, App Store and ad hoc builds
    #endif
    var request = URLRequest(url: URL(string: "https://api.example.com/me/push-token")!)
    request.httpMethod = "PUT"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    // Add your own sign-in header here, so your backend knows whose device this is.
    request.httpBody = try? JSONEncoder().encode([
        "token": token, "platform": "ios", "apns_environment": environment,
    ])
    _ = try? await URLSession.shared.data(for: request)
}

import android.Manifest
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.content.ContextCompat
import com.google.firebase.messaging.FirebaseMessaging
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage
import org.json.JSONObject
import java.io.IOException
import java.net.HttpURLConnection
import java.net.URL
import kotlin.concurrent.thread

class MainActivity : ComponentActivity() {
    private val askPermission = registerForActivityResult(ActivityResultContracts.RequestPermission()) { }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
            ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED
        ) {
            askPermission.launch(Manifest.permission.POST_NOTIFICATIONS)
        }
        // The current token, on every launch.
        FirebaseMessaging.getInstance().token.addOnSuccessListener { token -> sendTokenToBackend(token) }
    }
}

class PushService : FirebaseMessagingService() {
    // Google issued a new token: the old one stops working.
    override fun onNewToken(token: String) = sendTokenToBackend(token)

    // While the app is in the background, Android shows a push with a title and body
    // itself. This runs for those while the app is open, and for data-only and
    // encrypted pushes always. Nothing is shown unless you post the notification
    // here: the encryption page's Kotlin sample has a channel and a builder.
    override fun onMessageReceived(message: RemoteMessage) {}
}

/** Your own endpoint, called as the signed-in person. Your backend then calls PUT /v1/push/devices. */
fun sendTokenToBackend(token: String) {
    thread {
        var conn: HttpURLConnection? = null
        try {
            conn = URL("https://api.example.com/me/push-token").openConnection() as HttpURLConnection
            conn.requestMethod = "PUT"
            conn.doOutput = true
            conn.setRequestProperty("Content-Type", "application/json")
            // Add your own sign-in header here, so your backend knows whose device this is.
            val body = JSONObject().put("token", token).put("platform", "android").toString()
            conn.outputStream.use { it.write(body.toByteArray()) }
            conn.responseCode // sends the request and waits for the answer
        } catch (e: IOException) {
            // Offline or your backend is down: the next launch sends the token again.
        } finally {
            conn?.disconnect()
        }
    }
}