196 lines
8.4 KiB
Swift
196 lines
8.4 KiB
Swift
import SwiftUI
|
|
import UIKit
|
|
|
|
/// The tab bar, a navigation stack per tab, the mini player and the Now Playing sheet.
|
|
/// On an unfolded iPhone Duo the library sits on one side of the hinge and Now Playing on the other.
|
|
struct RootView: View {
|
|
@State private var ui = Ui(overlays: Overlays())
|
|
private var g: AppGraph { .shared }
|
|
|
|
var body: some View {
|
|
let s = g.settings
|
|
let p = Palette.of(s.theme, s.accent)
|
|
DuoSplit(onSplit: { ui.setSplit($0) }) {
|
|
TabView(selection: Binding(get: { ui.tab }, set: { ui.selectTab($0) })) {
|
|
ForEach(Tab.layout(s.tabLayout), id: \.self) { t in
|
|
NavigationStack(path: ui.path(t)) {
|
|
root(t).miniPlayerRoom()
|
|
.navigationDestination(for: Route.self) { destination($0).miniPlayerRoom() }
|
|
}
|
|
.modifier(FloatingMiniPlayer())
|
|
.tabItem { Label(t.rawValue, systemImage: t.icon) }
|
|
.tag(t)
|
|
}
|
|
}
|
|
.modifier(GlassMiniPlayerHost())
|
|
} docked: {
|
|
NowPlayingScreen(docked: true)
|
|
}
|
|
.background(p.bg.ignoresSafeArea())
|
|
.onChange(of: s.tabLayout) { _, _ in ui.ensureValidTab() }
|
|
.fullScreenCover(isPresented: Binding(get: { ui.nowPlayingOpen }, set: { ui.nowPlayingOpen = $0 })) {
|
|
NowPlayingScreen()
|
|
.overlayHost(ui.overlays, level: 1)
|
|
.environment(ui)
|
|
.environment(\.palette, p)
|
|
.preferredColorScheme(s.theme == .White ? .light : .dark)
|
|
.tint(p.accent)
|
|
}
|
|
.overlayHost(ui.overlays, level: 0)
|
|
.onChange(of: g.playback.message) { _, m in
|
|
if let m { ui.overlays.hud(m.text, "info.circle") }
|
|
}
|
|
.environment(ui)
|
|
.environment(\.palette, p)
|
|
.preferredColorScheme(s.theme == .White ? .light : .dark)
|
|
.tint(p.accent)
|
|
}
|
|
|
|
@ViewBuilder private func root(_ t: Tab) -> some View {
|
|
switch t {
|
|
case .Library: LibraryHome()
|
|
case .Songs: SongsScreen()
|
|
case .Albums: AlbumsScreen()
|
|
case .Artists: ArtistsScreen()
|
|
case .Genres: GenresScreen()
|
|
case .Playlists: PlaylistsScreen()
|
|
case .Search: SearchScreen()
|
|
case .Downloads: DownloadsScreen()
|
|
case .Settings: SettingsScreen()
|
|
}
|
|
}
|
|
|
|
@ViewBuilder private func destination(_ r: Route) -> some View {
|
|
switch r {
|
|
case .Artists: ArtistsScreen()
|
|
case .Albums: AlbumsScreen()
|
|
case .Songs: SongsScreen()
|
|
case .RecentlyAdded: SongsScreen(recent: true)
|
|
case .Playlists: PlaylistsScreen()
|
|
case .Genres: GenresScreen()
|
|
case .Downloads: DownloadsScreen()
|
|
case .DownloadQueue: DownloadQueueScreen()
|
|
case .TabBar: TabBarScreen()
|
|
case .WebRadio: WebRadioScreen()
|
|
case .GenrePage(let g): GenreScreen(genre: g)
|
|
case .Eq: EqScreen()
|
|
case .EqFilters(let id): EqFiltersScreen(profileId: id)
|
|
case .EqFilterPage(let id, let f): EqFilterPage(profileId: id, filterId: f)
|
|
case .Servers: ServersScreen()
|
|
case .ServerList: ServerListScreen()
|
|
case .Server(let id): ServerScreen(id: id)
|
|
case .StemServer: StemServerScreen()
|
|
case .Quality: QualityScreen()
|
|
case .Storage: StorageScreen()
|
|
case .Appearance: AppearanceScreen()
|
|
case .NowPlayingOptions: NowPlayingOptionsScreen()
|
|
case .StemEditor: StemEditorScreen()
|
|
case .About: AboutScreen()
|
|
case .ArtistPage(let a): ArtistScreen(artist: a)
|
|
case .AlbumPage(let a): AlbumScreen(album: a)
|
|
case .PlaylistPage(let pl): PlaylistScreen(playlist: pl)
|
|
case .StemPlaylistPage(let id): StemPlaylistScreen(id: id)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// iOS 26.1 and up put the mini player in the tab bar's glass accessory; older ones float a card over each tab.
|
|
private let glassAccessory: Bool = { if #available(iOS 26.1, *) { return true } else { return false } }()
|
|
|
|
private struct GlassMiniPlayerHost: ViewModifier {
|
|
@Environment(Ui.self) private var ui
|
|
private var g: AppGraph { .shared }
|
|
func body(content: Content) -> some View {
|
|
if #available(iOS 26.1, *) {
|
|
content
|
|
.tabViewBottomAccessory(isEnabled: g.playback.current != nil && !ui.split) { MiniPlayer() }
|
|
.tabBarMinimizeBehavior(.onScrollDown)
|
|
} else {
|
|
content
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Floats over the screens; each screen leaves room for it so nothing ends up underneath.
|
|
private struct FloatingMiniPlayer: ViewModifier {
|
|
@Environment(Ui.self) private var ui
|
|
private var g: AppGraph { .shared }
|
|
func body(content: Content) -> some View {
|
|
if glassAccessory || ui.split {
|
|
content
|
|
} else {
|
|
content
|
|
.overlay(alignment: .bottom) {
|
|
if g.playback.current != nil { MiniPlayer().transition(.move(edge: .bottom).combined(with: .opacity)) }
|
|
}
|
|
.animation(.spring(duration: 0.35), value: g.playback.current != nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct MiniPlayerRoom: ViewModifier {
|
|
@Environment(Ui.self) private var ui
|
|
private var g: AppGraph { .shared }
|
|
func body(content: Content) -> some View {
|
|
content.safeAreaInset(edge: .bottom, spacing: 0) {
|
|
if !glassAccessory && !ui.split && g.playback.current != nil { Color.clear.frame(height: 66) }
|
|
}
|
|
}
|
|
}
|
|
|
|
private extension View {
|
|
func miniPlayerRoom() -> some View { modifier(MiniPlayerRoom()) }
|
|
}
|
|
|
|
/// Splits the screen at the iPhone Duo's hinge (the system's division region): [library] on the
|
|
/// leading or top side, [docked] on the other. Anywhere without an active hinge it's just [library].
|
|
/// One layout for both states keeps the library's tab and scroll state across fold and unfold.
|
|
private struct DuoSplit<Library: View, Docked: View>: View {
|
|
var onSplit: (Bool) -> Void
|
|
@ViewBuilder var library: Library
|
|
@ViewBuilder var docked: Docked
|
|
|
|
var body: some View {
|
|
GeometryReader { geo in
|
|
let cut = Self.cut(geo)
|
|
let layout = cut?.vertical == false ? AnyLayout(VStackLayout(spacing: cut?.gap ?? 0)) : AnyLayout(HStackLayout(spacing: cut?.gap ?? 0))
|
|
layout {
|
|
library
|
|
.frame(width: cut.map { $0.vertical ? $0.first : geo.size.width } ?? geo.size.width,
|
|
height: cut.map { $0.vertical ? geo.size.height : $0.first } ?? geo.size.height)
|
|
if let cut {
|
|
docked
|
|
.frame(width: cut.vertical ? cut.second : geo.size.width,
|
|
height: cut.vertical ? geo.size.height : cut.second)
|
|
}
|
|
}
|
|
.onChange(of: cut != nil, initial: true) { _, on in onSplit(on) }
|
|
}
|
|
}
|
|
|
|
/// Where the hinge cuts the view: sizes of the two sides and the gap between them.
|
|
private struct Cut { var vertical: Bool; var first: CGFloat; var gap: CGFloat; var second: CGFloat }
|
|
|
|
private static func cut(_ geo: GeometryProxy) -> Cut? {
|
|
let size = geo.size
|
|
var c: Cut?
|
|
// The hinge reports inactive while the phone lies flat, so ask for inactive regions too.
|
|
if #available(iOS 27.1, *),
|
|
let r = geo.reservedRegions(kind: .division, options: .includeInactive).first?.frame {
|
|
let vertical = r.height >= r.width
|
|
c = vertical
|
|
? Cut(vertical: true, first: r.minX, gap: r.width, second: size.width - r.maxX)
|
|
: Cut(vertical: false, first: r.minY, gap: r.height, second: size.height - r.maxY)
|
|
} else if UIDevice.current.userInterfaceIdiom == .phone, size.width >= 760, size.height >= 560 {
|
|
// No region reported: only an unfolded Duo gives an iPhone this much room both ways.
|
|
// The hinge sits at the middle of the screen, not of the safe area, so place it from there.
|
|
let screenW = (UIApplication.shared.connectedScenes.first as? UIWindowScene)?.screen.bounds.width
|
|
let half = ((screenW ?? size.width) / 2 - geo.frame(in: .global).minX).rounded()
|
|
c = Cut(vertical: true, first: half - 12, gap: 24, second: size.width - half - 12)
|
|
}
|
|
guard let c else { return nil }
|
|
// A region that doesn't leave usable room on both sides isn't a hinge worth splitting at.
|
|
return c.first > 200 && c.second > 200 ? c : nil
|
|
}
|
|
}
|