enricobuehler
883c317872
The host has been able to describe a launcher entry since M2 — `role: "launcher"`,
the `steam_ui` and `launcher_ui` kinds — and the web console has grouped them into
their own rail since M4. No other client ever looked. `pf-client-core` decoded
`role` into an `is_launcher()` helper with zero call sites, and the shared console
model dropped the field entirely on its way to the renderer.
So a launcher tile arrived everywhere else as an ordinary game with no cover art:
indistinguishable from a title whose poster failed to load, sorted into the middle
of the alphabet, and captioned "Play".
One contract, implemented in each client's own idiom:
* launchers never interleave with titles — they lead, and each group keeps the
host's title order
* grid surfaces get a labelled section; a coverflow keeps its single carousel and
names the group the cursor is in, changing as it crosses the boundary. A second
focus rail would mean a new up/down nav model in three renderers for two or
three tiles
* an art-less launcher gets an accent face naming its launcher, not a title
monogram on the neutral one — "opens Steam", not "a cover that didn't load"
* anything that is not `"launcher"` is a game, and a host that omits the field
renders exactly as before (design D4's intended degradation)
* launching is unchanged: the client sends an id, the host resolves the recipe
The grouping is enforced once per client stack rather than per screen. In the
console UI it is an invariant of `LibraryShared::set_games`, so the cursor
arithmetic, the art pump and every future consumer inherit it; on Apple and Android
it is applied where the library is fetched/parsed.
Fixed in passing: the Apple and Android store badges were hard-coded
`isCustom ? "Custom" : "Steam"`, so every Lutris, GOG, Heroic, Epic and Xbox title
was labelled "Steam". Both now carry the same store table the Rust clients use.
The CLI's `--library` gains a fourth column (`game`/`launcher`), appended rather
than folded into an existing one so anything reading the first three is untouched.
Gates: punktfunk-host 436 passed / 0 failed and pf-console-ui 49 passed / 0 failed
on .21 (three new tests), workspace clippy -D warnings and cargo fmt --check clean
there; `swift build` of the full PunktfunkClient and `:app:compileDebugKotlin` clean
on macOS; `cargo check` + `clippy -D warnings` for the Windows client on .173.
Still unproven on hardware: no launcher tile has been clicked on a real host — that
needs the plugins published, which needs this branch's base merged first.
103 lines
3.6 KiB
Swift
103 lines
3.6 KiB
Swift
// Reusable library widgets, shared by the touch grid (LibraryView's `GameCard`) and the gamepad
|
|
// coverflow (LibraryCoverflowView's cover cell).
|
|
|
|
import PunktfunkKit
|
|
import SwiftUI
|
|
#if canImport(UIKit)
|
|
import UIKit
|
|
#elseif canImport(AppKit)
|
|
import AppKit
|
|
#endif
|
|
|
|
/// The store-provenance badge (Steam vs. a user-curated custom entry) overlaid on a poster —
|
|
/// shared by the touch grid's `GameCard` and the gamepad coverflow's cover cell.
|
|
struct StoreBadge: View {
|
|
/// Which store surfaced the entry, already resolved to a display name (`GameEntry.storeLabel`).
|
|
let label: String
|
|
/// A launcher entry (design D4) gets the brand fill, so "opens Steam" is legible at poster size
|
|
/// without reading the title.
|
|
var isLauncher: Bool = false
|
|
|
|
var body: some View {
|
|
Text(label)
|
|
.font(.geist(11, .semibold, relativeTo: .caption2))
|
|
.foregroundStyle(isLauncher ? AnyShapeStyle(.white) : AnyShapeStyle(.primary))
|
|
.padding(.horizontal, 6)
|
|
.padding(.vertical, 3)
|
|
.background(
|
|
isLauncher ? AnyShapeStyle(Color.brand) : AnyShapeStyle(.ultraThinMaterial),
|
|
in: Capsule())
|
|
.padding(6)
|
|
}
|
|
}
|
|
|
|
#if canImport(UIKit)
|
|
private typealias PlatformImage = UIImage
|
|
#elseif canImport(AppKit)
|
|
private typealias PlatformImage = NSImage
|
|
#endif
|
|
|
|
private extension Image {
|
|
init(platformImage: PlatformImage) {
|
|
#if canImport(UIKit)
|
|
self.init(uiImage: platformImage)
|
|
#elseif canImport(AppKit)
|
|
self.init(nsImage: platformImage)
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// Sequentially tries cover-art URLs over `session` (so a paired client can reach the host's own
|
|
/// art proxy, not just public CDNs — see `LibraryImageLoader`), advancing past any that fail to
|
|
/// load, then a placeholder. The loaded image is hard-clipped to fill the card's actual frame
|
|
/// regardless of its own aspect ratio: a portrait capsule fills it as intended, but a fallback
|
|
/// banner (wide hero/header art, used when a title has no portrait capsule) would otherwise report
|
|
/// a much wider intrinsic size than the card and overflow into neighboring cards. Not `private` —
|
|
/// the gamepad coverflow (`LibraryCoverflowView`) reuses it directly rather than re-fetching art.
|
|
struct PosterImage: View {
|
|
let candidates: [URL]
|
|
let title: String
|
|
let session: URLSession?
|
|
@State private var index = 0
|
|
@State private var image: PlatformImage?
|
|
|
|
var body: some View {
|
|
Group {
|
|
if let image {
|
|
Image(platformImage: image)
|
|
.resizable()
|
|
.scaledToFill()
|
|
} else if index < candidates.count {
|
|
ZStack { placeholder; ProgressView() }
|
|
} else {
|
|
placeholder
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, maxHeight: .infinity)
|
|
.clipped()
|
|
.task(id: index) { await loadCurrent() }
|
|
}
|
|
|
|
private func loadCurrent() async {
|
|
guard index < candidates.count else { return }
|
|
guard let session, let data = try? await session.data(from: candidates[index]).0,
|
|
let loaded = PlatformImage(data: data)
|
|
else {
|
|
index += 1 // advance to the next candidate (or past the end → placeholder)
|
|
return
|
|
}
|
|
image = loaded
|
|
}
|
|
|
|
private var placeholder: some View {
|
|
ZStack {
|
|
Rectangle().fill(.quaternary)
|
|
Text(title)
|
|
.font(.geist(17, .semibold, relativeTo: .headline))
|
|
.multilineTextAlignment(.center)
|
|
.foregroundStyle(.secondary)
|
|
.padding(8)
|
|
}
|
|
}
|
|
}
|