Anmeldung über die Plex-Seite statt über einen Code

Kein Code mehr zum Abtippen. Die Anmeldemaske kommt von Plex und öffnet
sich über ASWebAuthenticationSession in einem Fenster innerhalb der App;
nach dem Anmelden schickt Plex über forwardUrl auf ein eigenes Schema
zurück, das Fenster schließt sich von selbst.

Der PIN steckt weiterhin darunter — er ist der einzige Weg, auf dem Plex
einen Token herausgibt. Sichtbar ist er nicht mehr.

Was das bringt:
- Kein Fernseher-Gefühl mehr.
- Zwei-Faktor läuft mit, weil Plex die Seite selbst ausliefert.
- Das Passwort erreicht Flixy nie. Steht auch so unter dem Knopf.
- prefersEphemeralWebBrowserSession = false: wer in Safari schon bei
  Plex angemeldet ist, braucht nur zu bestätigen.

Zwei Details, die sonst still scheitern:
- Die Rückadresse wird strenger kodiert als die übrigen Werte. `:` und
  `/` lässt urlQueryAllowed durch, und für Plex endete der Wert dann
  beim ersten Schrägstrich — der Rücksprung käme nie.
- Das Schema muss in CFBundleURLTypes stehen, sonst kennt iOS es nicht
  und das Fenster bliebe offen stehen.

Als Schema die Bundle-Kennung statt eines kurzen Worts wie „flixy":
ein kurzes könnte eine andere App beanspruchen und die Anmeldung
abfangen.

132 Tests.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Flixy/Session/FlixySession.swift

@@ -14,8 +14,8 @@ final class FlixySession {
         /// Beim Start: liegt ein Token im Schlüsselbund?
         case launching
         case signedOut
-        /// Der Code steht bereit, der Nutzer bestätigt ihn im Browser.
-        case awaitingAuthorization(PlexPin)
+        /// Das Anmeldefenster von Plex ist offen.
+        case authenticating
         /// Mehrere Server am Konto — einer muss gewählt werden.
         case choosingServer([PlexResource])
         /// Ein Weg zum Server wird gesucht.
@@ -27,8 +27,8 @@ final class FlixySession {
             switch (lhs, rhs) {
             case (.launching, .launching), (.signedOut, .signedOut), (.ready, .ready):
                 true
-            case (.awaitingAuthorization(let l), .awaitingAuthorization(let r)):
-                l.id == r.id
+            case (.authenticating, .authenticating):
+                true
             case (.choosingServer(let l), .choosingServer(let r)):
                 l.map(\.clientIdentifier) == r.map(\.clientIdentifier)
             case (.connecting(let l), .connecting(let r)):
@@ -58,6 +58,7 @@ final class FlixySession {
     private let identity: PlexClientIdentity
     private let tokenStore: any TokenStoring
     private let authenticator: PlexAuthenticator
+    private let webAuthenticator = PlexWebAuthenticator()
     private let defaults: UserDefaults
     private var authorizationTask: Task<Void, Never>?
 
@@ -85,11 +86,47 @@ final class FlixySession {
 
     // MARK: - Anmeldung
 
+    /// Öffnet die Anmeldeseite von Plex.
+    ///
+    /// Der PIN steckt weiterhin darunter — er ist der einzige Weg, auf dem
+    /// Plex einen Token herausgibt. Sichtbar ist er nicht mehr: Plex liefert
+    /// seine eigene Anmeldemaske aus und schickt die App danach über
+    /// `forwardUrl` zurück.
     func beginSignIn() async {
+        phase = .authenticating
+
         do {
             let pin = try await authenticator.requestPin()
-            phase = .awaitingAuthorization(pin)
-            waitForAuthorization(of: pin)
+
+            guard let url = pin.authorizationURL(
+                clientIdentifier: identity.clientIdentifier,
+                product: Branding.plexProduct,
+                forwardURL: Branding.authCallbackURL
+            ) else {
+                phase = .failed(message: String(localized: "signIn.windowFailed"))
+                return
+            }
+
+            try await webAuthenticator.authenticate(
+                url: url,
+                callbackScheme: Branding.urlScheme
+            )
+
+            // Das Fenster ist zu, jetzt liegt der Token bereit. Kurz
+            // nachgefragt statt sofort erwartet: zwischen dem Rücksprung und
+            // dem Eintrag bei Plex liegen manchmal ein, zwei Sekunden.
+            let token = try await authenticator.waitForAuthorization(
+                pin: pin,
+                pollInterval: .milliseconds(500),
+                timeout: .seconds(20)
+            )
+            await connect(accountToken: token)
+
+        } catch PlexWebAuthenticator.Failure.cancelled {
+            // Fenster geschlossen. Kein Fehler — kommentarlos zurück.
+            phase = .signedOut
+        } catch let error as PlexWebAuthenticator.Failure {
+            phase = .failed(message: webAuthenticationMessage(for: error))
         } catch {
             phase = .failed(message: message(for: error))
         }
@@ -101,17 +138,10 @@ final class FlixySession {
         phase = .signedOut
     }
 
-    private func waitForAuthorization(of pin: PlexPin) {
-        authorizationTask?.cancel()
-        authorizationTask = Task { [authenticator] in
-            do {
-                let token = try await authenticator.waitForAuthorization(pin: pin)
-                guard !Task.isCancelled else { return }
-                await connect(accountToken: token)
-            } catch {
-                guard !Task.isCancelled else { return }
-                phase = .failed(message: message(for: error))
-            }
+    private func webAuthenticationMessage(for failure: PlexWebAuthenticator.Failure) -> String {
+        switch failure {
+        case .cancelled: String(localized: "signIn.cancelled")
+        case .presentationFailed(let description): description
         }
     }
 

Flixy/Session/PlexWebAuthenticator.swift

@@ -0,0 +1,74 @@
+import AuthenticationServices
+import Foundation
+import UIKit
+
+/// Öffnet die Anmeldeseite von Plex in einem Fenster innerhalb der App.
+///
+/// `ASWebAuthenticationSession` ist dafür der vorgesehene Weg: die Seite kommt
+/// von Plex, das Passwort wird dort eingegeben und erreicht die App nie. Nach
+/// dem Anmelden schickt Plex den Browser auf eine Adresse mit unserem eigenen
+/// Schema, das Fenster schließt sich von selbst, und die App weiß, dass sie
+/// den Token abholen kann.
+///
+/// Ein einfacher `SFSafariViewController` täte es nicht: er meldet nicht, wann
+/// die Rückadresse erreicht wurde, und müsste von Hand geschlossen werden.
+@MainActor
+final class PlexWebAuthenticator: NSObject {
+    enum Failure: Error, Equatable {
+        /// Der Nutzer hat das Fenster geschlossen. Kein Fehler im eigentlichen
+        /// Sinn — die Oberfläche soll darauf kommentarlos zurückgehen.
+        case cancelled
+        case presentationFailed(String)
+    }
+
+    /// Führt die Anmeldung durch und kehrt zurück, sobald Plex die App
+    /// zurückgeschickt hat.
+    func authenticate(url: URL, callbackScheme: String) async throws(Failure) {
+        do {
+            try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, any Error>) in
+                let session = ASWebAuthenticationSession(
+                    url: url,
+                    callbackURLScheme: callbackScheme
+                ) { _, error in
+                    if let error {
+                        continuation.resume(throwing: error)
+                    } else {
+                        continuation.resume()
+                    }
+                }
+
+                session.presentationContextProvider = self
+                // `false`, damit eine bestehende Plex-Anmeldung in Safari
+                // mitgenutzt wird: wer dort schon angemeldet ist, braucht nur
+                // zu bestätigen statt das Passwort erneut einzugeben.
+                session.prefersEphemeralWebBrowserSession = false
+
+                guard session.start() else {
+                    continuation.resume(throwing: Failure.presentationFailed(
+                        String(localized: "signIn.windowFailed")
+                    ))
+                    return
+                }
+            }
+        } catch let error as ASWebAuthenticationSessionError where error.code == .canceledLogin {
+            throw .cancelled
+        } catch let error as Failure {
+            throw error
+        } catch {
+            throw .presentationFailed(error.localizedDescription)
+        }
+    }
+}
+
+extension PlexWebAuthenticator: ASWebAuthenticationPresentationContextProviding {
+    func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
+        // Das Fenster der App. Über die verbundenen Szenen gesucht, weil eine
+        // SwiftUI-App keinen festen Verweis darauf hat — und ein frisch
+        // erzeugtes Fenster erschiene hinter dem sichtbaren.
+        let scene = UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .first { $0.activationState == .foregroundActive }
+
+        return scene?.keyWindow ?? ASPresentationAnchor()
+    }
+}