geesawra.industries/hydraulophone
An unofficial YouTube Music app for iPhone, iPad, and Mac.
0
0
import HydraulophoneCore
import SwiftUI
@MainActor
final class CollectionTracksViewModel: ObservableObject {
enum Source: Hashable, Sendable {
case playlist(Playlist)
case album(Album)
var key: String {
switch self {
case .playlist(let playlist):
return "playlist:\(playlist.routeIdentity)"
case .album(let album):
return "album:\(album.id)"
}
}
var title: String {
switch self {
case .playlist(let playlist): return playlist.title
case .album(let album): return album.title
}
}
var subtitle: String? {
switch self {
case .playlist(let playlist): return playlist.subtitle
case .album(let album): return album.subtitle
}
}
var thumbnailURL: URL? {
switch self {
case .playlist(let playlist): return playlist.thumbnailURL
case .album(let album): return album.thumbnailURL
}
}
var showsTrackDetails: Bool { true }
var showsTrackArtwork: Bool {
if case .album = self { return false }
return true
}
}
let source: Source
private let service: any MusicService
private var fallbackAlbumArtworkURL: URL?
private var requestTask: Task<Void, Never>?
private var requestGeneration = UUID()
private var continuation: PaginationToken?
private var seenContinuationValues: Set<String> = []
@Published private(set) var songs: [Song] = []
@Published private(set) var header: CatalogPageHeader?
@Published private(set) var isLoading = false
@Published private(set) var isRefreshing = false
@Published private(set) var isLoadingMore = false
@Published private(set) var hasMore = false
@Published var errorMessage: String?
@Published private(set) var refreshErrorMessage: String?
@Published private(set) var loadMoreErrorMessage: String?
/// Changes only when a pagination request added at least one unique song.
/// The view uses it to extend a queue created from this exact collection.
@Published private(set) var appendGeneration = 0
/// Changes after each successful first-page replacement. Queue tracking must
/// be detached from a refreshed list, even when playback remains active.
@Published private(set) var replacementGeneration = 0
init(playlist: Playlist, service: any MusicService) {
source = .playlist(playlist)
self.service = service
}
init(album: Album, service: any MusicService) {
source = .album(album)
self.service = service
}
/// Browse headers supply artwork and credits missing from track navigation links.
var displayAlbum: Album? {
guard case .album(let album) = source else { return nil }
return Album(
browseID: album.browseID, playlistID: album.playlistID, title: album.title,
subtitle: header?.subtitle ?? album.subtitle,
thumbnailURL: header?.thumbnailURL ?? album.thumbnailURL
?? fallbackAlbumArtworkURL,
artistReferences: header?.artistReferences ?? album.artistReferences, params: album.params)
}
deinit {
requestTask?.cancel()
}
func clear() {
requestTask?.cancel()
requestTask = nil
requestGeneration = UUID()
songs = []
header = nil
fallbackAlbumArtworkURL = nil
continuation = nil
seenContinuationValues.removeAll()
hasMore = false
isLoading = false
isRefreshing = false
isLoadingMore = false
errorMessage = nil
refreshErrorMessage = nil
loadMoreErrorMessage = nil
}
func load() async {
guard !isLoading, !isRefreshing, !isLoadingMore else { return }
requestTask?.cancel()
let generation = UUID()
requestGeneration = generation
songs = []
header = nil
fallbackAlbumArtworkURL = nil
continuation = nil
seenContinuationValues.removeAll()
hasMore = true
isLoading = true
errorMessage = nil
refreshErrorMessage = nil
loadMoreErrorMessage = nil
let task = Task { [weak self] in
guard let self else { return }
await self.performInitialLoad(
generation: generation,
preserveContent: false,
policy: .reload
)
}
requestTask = task
await withTaskCancellationHandler(
operation: {
await task.value
},
onCancel: {
task.cancel()
})
if requestGeneration == generation {
requestTask = nil
}
}
func refresh() async {
guard !isLoading, !isRefreshing, !isLoadingMore else { return }
requestTask?.cancel()
let generation = UUID()
requestGeneration = generation
isRefreshing = true
refreshErrorMessage = nil
loadMoreErrorMessage = nil
let task = Task { [weak self] in
guard let self else { return }
await self.performInitialLoad(
generation: generation,
preserveContent: true,
policy: .reload
)
}
requestTask = task
await withTaskCancellationHandler(
operation: {
await task.value
},
onCancel: {
task.cancel()
})
if requestGeneration == generation {
requestTask = nil
}
}
func retry() async {
if let loadMoreErrorMessage, !loadMoreErrorMessage.isEmpty {
await loadMore()
} else {
await load()
}
}
func loadMoreIfNeeded(index: Int) async {
guard !songs.isEmpty, index >= max(songs.count - 4, 0) else { return }
await loadMore()
}
func loadMore() async {
guard hasMore, let continuation, !isLoading, !isRefreshing, !isLoadingMore else {
return
}
let generation = requestGeneration
isLoadingMore = true
loadMoreErrorMessage = nil
let task = Task { [weak self] in
guard let self else { return }
await self.performMoreLoad(continuation: continuation, generation: generation)
}
requestTask = task
await withTaskCancellationHandler(
operation: {
await task.value
},
onCancel: {
task.cancel()
})
if requestGeneration == generation {
requestTask = nil
}
}
func reloadAfterSessionTransition() async {
await load()
}
private func performInitialLoad(
generation: UUID,
preserveContent: Bool,
policy: CatalogLoadPolicy
) async {
defer {
if requestGeneration == generation {
isLoading = false
isRefreshing = false
}
}
do {
let page = try await loadPage(continuation: nil, policy: policy)
guard requestGeneration == generation, !Task.isCancelled else { return }
if case .album = source {
fallbackAlbumArtworkURL =
page.items.lazy.compactMap(\.thumbnailURL).first
?? fallbackAlbumArtworkURL
}
header = page.header?.fillingMissingValues(from: header) ?? header
songs = uniqueSongs(page.items).map(applyingCollectionMetadata)
replacementGeneration += 1
continuation = nil
seenContinuationValues.removeAll()
hasMore = false
if !page.items.isEmpty, let next = page.next,
seenContinuationValues.insert(next.rawValue).inserted
{
continuation = next
hasMore = true
}
if preserveContent {
errorMessage = nil
refreshErrorMessage = nil
} else {
errorMessage = nil
}
} catch is CancellationError {
return
} catch {
guard requestGeneration == generation else { return }
let message = (error as? LocalizedError)?.errorDescription ?? "Could not load songs."
if preserveContent {
refreshErrorMessage = message
} else {
songs = []
continuation = nil
hasMore = false
errorMessage = message
}
}
}
private func performMoreLoad(
continuation requestedContinuation: PaginationToken,
generation: UUID
) async {
defer {
if requestGeneration == generation {
isLoadingMore = false
}
}
do {
let page = try await loadPage(continuation: requestedContinuation, policy: .cacheFirst)
guard requestGeneration == generation, !Task.isCancelled else { return }
var existingIDs = Set(songs.map(\.id))
var didAppend = false
for song in page.items where existingIDs.insert(song.id).inserted {
songs.append(applyingCollectionMetadata(to: song))
didAppend = true
}
if didAppend {
appendGeneration += 1
}
updateContinuation(after: page)
loadMoreErrorMessage = nil
} catch is CancellationError {
return
} catch {
guard requestGeneration == generation else { return }
loadMoreErrorMessage =
(error as? LocalizedError)?.errorDescription ?? "Could not load more songs."
}
}
private func loadPage(
continuation: PaginationToken?,
policy: CatalogLoadPolicy
) async throws -> Page<Song> {
switch source {
case .playlist(let playlist):
if let paginatedService = service as? any PaginatedCatalogMusicService {
return try await paginatedService.trackPage(
in: playlist,
continuation: continuation,
policy: policy
)
}
return Page(items: try await service.tracks(in: playlist))
case .album(let album):
if let paginatedService = service as? any PaginatedCatalogMusicService {
return try await paginatedService.albumTrackPage(
in: album,
continuation: continuation,
policy: policy
)
}
// MusicService predates album collections. A fake can still provide
// album data by exposing it through the same legacy track-array method.
let legacyPlaylist = Playlist(
id: album.playlistID ?? album.id,
title: album.title,
subtitle: album.subtitle,
thumbnailURL: album.thumbnailURL
)
return Page(items: try await service.tracks(in: legacyPlaylist))
}
}
private func uniqueSongs(_ values: [Song]) -> [Song] {
var seenIDs: Set<String> = []
return values.filter { seenIDs.insert($0.id).inserted }
}
private func applyingCollectionMetadata(to song: Song) -> Song {
guard let album = displayAlbum else { return song }
return CollectionTrackMetadata.applying(song, from: album)
}
private func updateContinuation(after page: Page<Song>) {
guard !page.items.isEmpty, let next = page.next else {
continuation = nil
hasMore = false
return
}
guard seenContinuationValues.insert(next.rawValue).inserted else {
continuation = nil
hasMore = false
return
}
continuation = next
hasMore = true
}
}
enum CollectionTrackMetadata {
static func applying(_ song: Song, from album: Album) -> Song {
// Album rows can omit artwork already shown in the collection header.
// Carry that context into the queue so every playback surface has it,
// including tracks added by a later continuation page.
let parsedArtist = song.artist.trimmingCharacters(in: .whitespacesAndNewlines)
let linkedArtists = album.artistReferences?.map(\.title).filter { !$0.isEmpty }
.joined(separator: ", ")
let needsArtist =
parsedArtist.isEmpty || parsedArtist.caseInsensitiveCompare("Unknown artist") == .orderedSame
let albumArtistName =
linkedArtists.flatMap { $0.isEmpty ? nil : $0 }
?? albumArtist(from: album.subtitle)
let artist = needsArtist ? albumArtistName ?? song.artist : song.artist
// A known guest credit must not navigate to the album's primary artist.
let inheritsArtistReferences =
needsArtist
|| parsedArtist.caseInsensitiveCompare(albumArtistName ?? "") == .orderedSame
return Song(
id: song.id,
title: song.title,
artist: artist,
album: song.album ?? album.title,
durationText: song.durationText,
thumbnailURL: song.thumbnailURL ?? album.thumbnailURL,
artistReferences: song.artistReferences
?? (inheritsArtistReferences ? album.artistReferences : nil),
albumReference: song.albumReference ?? album
)
}
private static func albumArtist(from subtitle: String?) -> String? {
guard let subtitle else { return nil }
let parts = subtitle.split(separator: "•").map {
$0.trimmingCharacters(in: .whitespacesAndNewlines)
}.filter { !$0.isEmpty }
let artist: String
if parts.count == 1 {
artist = parts[0]
} else if parts.count > 1,
["album", "ep", "single"].contains(parts[0].lowercased())
{
artist = parts[1]
} else {
return nil
}
guard artist.caseInsensitiveCompare("Unknown artist") != .orderedSame,
!["album", "ep", "single"].contains(artist.lowercased()),
Int(artist) == nil
else { return nil }
return artist
}
}
/// App-facing constructor for playlist collections.
struct CollectionTracksView: View {
private let source: CollectionTracksViewModel.Source
private let injectedService: (any MusicService)?
private let injectedPlayback: PlaybackController?
@EnvironmentObject private var model: AppModel
init(playlist: Playlist) {
source = .playlist(playlist)
injectedService = nil
injectedPlayback = nil
}
init(album: Album) {
source = .album(album)
injectedService = nil
injectedPlayback = nil
}
init(
playlist: Playlist,
service: any MusicService,
playback: PlaybackController
) {
source = .playlist(playlist)
injectedService = service
injectedPlayback = playback
}
init(
album: Album,
service: any MusicService,
playback: PlaybackController
) {
source = .album(album)
injectedService = service
injectedPlayback = playback
}
var body: some View {
CollectionTracksContent(
source: source,
service: injectedService ?? model.musicService,
playback: injectedPlayback ?? model.playback
)
}
}
/// Compatibility name retained for routes and callers from the first
/// collection implementation.
struct PlaylistTracksView: View {
private let playlist: Playlist
private let injectedService: (any MusicService)?
private let injectedPlayback: PlaybackController?
@EnvironmentObject private var model: AppModel
init(playlist: Playlist) {
self.playlist = playlist
injectedService = nil
injectedPlayback = nil
}
init(
playlist: Playlist,
service: any MusicService,
playback: PlaybackController
) {
self.playlist = playlist
injectedService = service
injectedPlayback = playback
}
var body: some View {
CollectionTracksContent(
source: .playlist(playlist),
service: injectedService ?? model.musicService,
playback: injectedPlayback ?? model.playback
)
}
}
private struct CollectionTracksContent: View {
let source: CollectionTracksViewModel.Source
let service: any MusicService
@ObservedObject var playback: PlaybackController
@EnvironmentObject private var model: AppModel
@Environment(\.accessibilityReduceMotion) private var reduceMotion
@StateObject private var viewModel: CollectionTracksViewModel
@State private var queuedCollectionKey: String?
@State private var queuedSongIDs: [String]?
@State private var queuedReplacementGeneration: Int?
@State private var handledAppendGeneration = 0
@State private var handledReplacementGeneration = 0
init(
source: CollectionTracksViewModel.Source,
service: any MusicService,
playback: PlaybackController
) {
self.source = source
self.service = service
_playback = ObservedObject(wrappedValue: playback)
switch source {
case .playlist(let playlist):
_viewModel = StateObject(
wrappedValue: CollectionTracksViewModel(playlist: playlist, service: service)
)
case .album(let album):
_viewModel = StateObject(
wrappedValue: CollectionTracksViewModel(album: album, service: service)
)
}
}
var body: some View {
Group {
if model.isRestoringSession || model.isSessionTransitioning {
restoringState
} else {
collectionScrollView
}
}
.background(HydraulophoneTheme.groupedBackground)
.navigationTitle(viewModel.source.title)
.navigationBarTitleDisplayMode(.inline)
.toolbar {
if let album = viewModel.displayAlbum {
ToolbarItem(placement: .topBarTrailing) {
AlbumDownloadButton(
album: album, downloads: model.downloads, quality: model.settings.preferredQuality)
}
}
}
.task(id: model.catalogSessionID) {
guard !model.isSessionTransitioning,
!model.isRestoringSession
else {
viewModel.clear()
clearQueueTracking()
return
}
await viewModel.load()
}
.onChange(of: model.isSessionTransitioning) { _, isTransitioning in
if isTransitioning {
viewModel.clear()
clearQueueTracking()
} else if !model.isRestoringSession {
Task { await viewModel.reloadAfterSessionTransition() }
}
}
.onChange(of: model.session) { _, session in
if session == nil {
viewModel.clear()
clearQueueTracking()
}
}
.onChange(of: viewModel.appendGeneration) { _, generation in
guard generation != handledAppendGeneration else { return }
handledAppendGeneration = generation
appendNewSongsToCurrentQueue()
}
.onChange(of: viewModel.replacementGeneration) { _, generation in
guard generation != handledReplacementGeneration else { return }
handledReplacementGeneration = generation
clearQueueTracking()
}
.tint(HydraulophoneTheme.accent)
}
private var collectionScrollView: some View {
ScrollView {
VStack(alignment: .leading, spacing: 20) {
collectionHeader
collectionActions
tracksContent
}
.padding(.horizontal, 20)
.padding(.bottom, 24)
.animation(reduceMotion ? nil : .easeInOut(duration: 0.2), value: viewModel.songs)
.frame(maxWidth: 860)
.frame(maxWidth: .infinity)
}
.refreshable {
guard !model.isSessionTransitioning, !model.isRestoringSession else { return }
await viewModel.refresh()
}
}
private var collectionActions: some View {
MusicPlaybackActions(
isEnabled: !viewModel.songs.isEmpty,
play: { playSong(at: 0, shuffle: false) },
shuffle: { playSong(at: 0, shuffle: true) }
)
}
private var restoringState: some View {
VStack(spacing: 14) {
ProgressView()
.controlSize(.large)
Text("Restoring your collection…")
.font(.subheadline)
.foregroundStyle(.secondary)
}
.frame(maxWidth: .infinity, minHeight: 260)
.accessibilityElement(children: .combine)
.accessibilityLabel("Restoring your collection")
}
@ViewBuilder
private var collectionHeader: some View {
if let album = viewModel.displayAlbum {
AlbumDetailHeader(album: album)
} else {
playlistHeader
}
}
private var playlistHeader: some View {
HStack(alignment: .top, spacing: 16) {
ArtworkView(
url: viewModel.source.thumbnailURL,
size: 128,
cornerRadius: 14
)
VStack(alignment: .leading, spacing: 8) {
Text(viewModel.source.title)
.font(.title2.weight(.bold))
.lineLimit(3)
if let subtitle = viewModel.source.subtitle, !subtitle.isEmpty {
Text(subtitle)
.font(.subheadline)
.foregroundStyle(.secondary)
.lineLimit(2)
}
if !viewModel.songs.isEmpty {
Text("\(viewModel.songs.count) songs")
.font(.caption)
.foregroundStyle(.secondary)
}
}
.frame(maxWidth: .infinity, alignment: .leading)
}
.padding(.top, 12)
}
@ViewBuilder
private var tracksContent: some View {
if (viewModel.isLoading || viewModel.isRefreshing) && viewModel.songs.isEmpty {
ProgressView("Loading songs…")
.frame(maxWidth: .infinity, minHeight: 200)
} else if let errorMessage = viewModel.errorMessage, viewModel.songs.isEmpty {
HydraulophoneErrorState(
title: "Could not load songs",
message: errorMessage,
retry: {
Task { await viewModel.retry() }
}
)
.frame(maxWidth: .infinity, minHeight: 220)
} else if let refreshErrorMessage = viewModel.refreshErrorMessage,
viewModel.songs.isEmpty
{
HydraulophoneErrorState(
title: "Collection refresh failed",
message: refreshErrorMessage,
retry: {
Task { await viewModel.refresh() }
}
)
.frame(maxWidth: .infinity, minHeight: 220)
} else if viewModel.songs.isEmpty {
VStack(spacing: 12) {
ContentUnavailableView("This collection is empty", systemImage: "music.note.list")
.frame(maxWidth: .infinity, minHeight: 200)
if viewModel.hasMore {
collectionPaginationFooter
}
}
} else {
VStack(alignment: .leading, spacing: 12) {
if let message = viewModel.refreshErrorMessage {
CollectionRefreshErrorBanner(message: message) {
Task { await viewModel.refresh() }
}
}
LazyVStack(spacing: 0) {
ForEach(Array(viewModel.songs.enumerated()), id: \.element.id) { index, song in
SongRow(
song: song,
accessibilityIdentifier: HydraulophoneAccessibilityID.track(song.id),
trackNumber: index + 1,
showsDetails: viewModel.source.showsTrackDetails,
showsArtwork: viewModel.source.showsTrackArtwork,
playNext: { playback.enqueueNext(song) },
addToQueue: { playback.enqueue(song) }
) {
playSong(at: index)
}
.onAppear {
Task { await viewModel.loadMoreIfNeeded(index: index) }
}
Divider()
}
}
collectionPaginationFooter
}
}
}
@ViewBuilder
private var collectionPaginationFooter: some View {
if viewModel.isLoadingMore {
ProgressView("Loading more songs…")
.frame(maxWidth: .infinity)
.padding(.vertical, 10)
.accessibilityElement(children: .combine)
} else if let message = viewModel.loadMoreErrorMessage {
HStack(spacing: 10) {
Text(message)
.font(.footnote)
.foregroundStyle(.secondary)
.frame(maxWidth: .infinity, alignment: .leading)
Button("Retry") {
Task { await viewModel.loadMore() }
}
.frame(minHeight: 44)
}
.padding(.vertical, 4)
.accessibilityElement(children: .contain)
} else if viewModel.hasMore && !viewModel.isLoading && !viewModel.isRefreshing {
Button("Load more") {
Task { await viewModel.loadMore() }
}
.frame(maxWidth: .infinity, minHeight: 44)
.padding(.vertical, 4)
} else if !viewModel.hasMore {
Text("End of songs")
.font(.footnote)
.foregroundStyle(.secondary)
.frame(maxWidth: .infinity)
.padding(.vertical, 10)
.accessibilityLabel("End of songs")
}
}
private func playSong(at index: Int, shuffle: Bool? = nil) {
let songs = viewModel.songs
guard songs.indices.contains(index) else { return }
playback.setQueue(songs, startAt: index, shuffle: shuffle)
queuedCollectionKey = viewModel.source.key
queuedSongIDs = songs.map(\.id)
queuedReplacementGeneration = viewModel.replacementGeneration
}
private func appendNewSongsToCurrentQueue() {
guard queuedCollectionKey == viewModel.source.key,
let queuedSongIDs,
queuedReplacementGeneration == viewModel.replacementGeneration,
playback.currentSong != nil,
playback.queue.map(\.id) == queuedSongIDs
else {
return
}
let additions = viewModel.songs.filter { !queuedSongIDs.contains($0.id) }
guard !additions.isEmpty else { return }
for song in additions {
playback.enqueue(song)
}
self.queuedSongIDs = queuedSongIDs + additions.map(\.id)
}
private func clearQueueTracking() {
queuedCollectionKey = nil
queuedSongIDs = nil
queuedReplacementGeneration = nil
handledAppendGeneration = viewModel.appendGeneration
handledReplacementGeneration = viewModel.replacementGeneration
}
}
private struct CollectionRefreshErrorBanner: View {
let message: String
let retry: () -> Void
var body: some View {
HStack(alignment: .top, spacing: 10) {
Image(systemName: "exclamationmark.triangle.fill")
.foregroundStyle(.orange)
Text("Refresh failed: \(message)")
.font(.footnote)
.foregroundStyle(.secondary)
.frame(maxWidth: .infinity, alignment: .leading)
Button("Retry", action: retry)
.font(.footnote.weight(.semibold))
.frame(minHeight: 44)
}
.padding(.horizontal, 12)
.padding(.vertical, 8)
.background(.regularMaterial, in: RoundedRectangle(cornerRadius: 10))
.accessibilityElement(children: .combine)
.accessibilityLabel("Collection refresh failed. \(message)")
}
}