Initial Commit
This commit is contained in:
@@ -0,0 +1,636 @@
|
||||
import SwiftUI
|
||||
import UniformTypeIdentifiers
|
||||
|
||||
enum EntityKind: String, Identifiable {
|
||||
case singer, venue
|
||||
var id: String { rawValue }
|
||||
var title: String { self == .singer ? "Singer" : "Venue" }
|
||||
var table: String { self == .singer ? "singers" : "venues" }
|
||||
}
|
||||
|
||||
@MainActor final class AppModel: ObservableObject {
|
||||
@Published var songs = [Song]()
|
||||
@Published var singers = [PersonPlace]()
|
||||
@Published var venues = [PersonPlace]()
|
||||
@Published var venueSingers = [PersonPlace]()
|
||||
@Published var playlists = [PersonPlace]()
|
||||
@Published var queue = [QueueEntry]()
|
||||
@Published var history = [Performance]()
|
||||
@Published private(set) var currentVenue: Int64?
|
||||
@Published var selectedSinger: Int64?
|
||||
@Published var autoAdvance = true
|
||||
@Published var error: String?
|
||||
@Published var creating: EntityKind?
|
||||
let player = Player()
|
||||
private(set) var library: Library?
|
||||
let root: URL
|
||||
var currentVenueName: String { venues.first { $0.id == currentVenue }?.name ?? "No venue selected" }
|
||||
init(storageURL: URL? = nil) {
|
||||
root = storageURL ?? FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0].appendingPathComponent("KJamsClone")
|
||||
perform {
|
||||
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
|
||||
library = try Library(url:root.appendingPathComponent("Library.sqlite")); try refresh()
|
||||
}
|
||||
player.onFinished = { [weak self] in
|
||||
guard let self, self.autoAdvance, !self.queue.isEmpty else { return }
|
||||
self.playQueueNext()
|
||||
}
|
||||
}
|
||||
func perform(_ work: () throws -> Void) { do { try work() } catch { self.error = error.localizedDescription } }
|
||||
func refresh() throws {
|
||||
guard let library else { throw LibraryError.message("Library unavailable") }
|
||||
songs = try library.songs(); singers = try library.entities("singers"); venues = try library.entities("venues")
|
||||
playlists = try library.entities("playlists"); currentVenue = try library.currentVenue()
|
||||
venueSingers = try currentVenue.map { try library.members(of:$0) } ?? singers
|
||||
if let selectedSinger, !venueSingers.contains(where: { $0.id == selectedSinger }) { self.selectedSinger = nil }
|
||||
queue = try library.queue(venue:currentVenue); history = try library.history(venue:currentVenue)
|
||||
}
|
||||
func chooseVenue(_ id: Int64?) {
|
||||
perform {
|
||||
guard let library else { throw LibraryError.message("Library unavailable") }
|
||||
try library.selectVenue(id); selectedSinger = nil; try refresh()
|
||||
}
|
||||
}
|
||||
func membership(singer: Int64, included: Bool) {
|
||||
perform {
|
||||
guard let library, let currentVenue else { throw LibraryError.message("Select a current venue first") }
|
||||
try library.setMembership(singer:singer,venue:currentVenue,included:included); try refresh()
|
||||
}
|
||||
}
|
||||
@discardableResult func createEntity(_ kind: EntityKind, name: String) throws -> Int64 {
|
||||
guard let library else { throw LibraryError.message("Library unavailable") }
|
||||
let trimmed = name.trimmingCharacters(in:.whitespacesAndNewlines)
|
||||
try library.addEntity(kind.table,name:trimmed)
|
||||
guard let entity = try library.entities(kind.table).first(where: { $0.name == trimmed }) else { throw LibraryError.message("Could not load new entry") }
|
||||
if kind == .singer {
|
||||
if let currentVenue { try library.setMembership(singer:entity.id,venue:currentVenue,included:true) }
|
||||
selectedSinger = entity.id
|
||||
} else { try library.selectVenue(entity.id); selectedSinger = nil }
|
||||
try refresh(); return entity.id
|
||||
}
|
||||
func rename(_ table: String, id: Int64, name: String) { perform { try library?.rename(table,id:id,name:name); try refresh() } }
|
||||
func delete(_ table: String, id: Int64) { perform { try library?.deleteEntity(table,id:id); try refresh() } }
|
||||
func preference(_ song: Int64) -> SongPreference {
|
||||
guard let library, let selectedSinger else { return .init() }
|
||||
return (try? library.preference(song:song,singer:selectedSinger)) ?? .init()
|
||||
}
|
||||
func savePreference(song: Int64, value: SongPreference) {
|
||||
perform {
|
||||
guard let library, let selectedSinger else { throw LibraryError.message("Select a singer to save their song preferences") }
|
||||
try library.savePreference(song:song,singer:selectedSinger,value:value); try refresh()
|
||||
}
|
||||
}
|
||||
func play(_ song: Song, singer: Int64? = nil) throws {
|
||||
guard let library else { throw LibraryError.message("Library unavailable") }
|
||||
let singer = singer ?? selectedSinger
|
||||
if let singer, let currentVenue, try !library.members(of:currentVenue).contains(where: { $0.id == singer }) { throw LibraryError.message("This singer is not in the current venue") }
|
||||
let preference = try singer.map { try library.preference(song:song.id,singer:$0) } ?? SongPreference()
|
||||
try player.load(song,preference:preference)
|
||||
do { try library.record(song.id,singer:singer,venue:currentVenue); selectedSinger = singer; try refresh() }
|
||||
catch { player.stop(); throw error }
|
||||
}
|
||||
func enqueue(_ song: Int64) { perform { try library?.enqueue(song:song,singer:selectedSinger,venue:currentVenue); try refresh() } }
|
||||
func playQueueNext() {
|
||||
perform {
|
||||
guard let row = queue.first, let song = songs.first(where: { $0.id == row.songID }) else { return }
|
||||
// Explicitly clear selection for unassigned queue entries.
|
||||
selectedSinger = row.singerID
|
||||
try play(song,singer:row.singerID); try library?.removeQueue(row.id); try refresh()
|
||||
}
|
||||
}
|
||||
func moveQueue(_ id: Int64, by offset: Int) { perform { if let currentVenue { try library?.moveQueue(id,venue:currentVenue,by:offset); try refresh() } } }
|
||||
func removeQueue(_ id: Int64) { perform { try library?.removeQueue(id); try refresh() } }
|
||||
func createPlaylist(_ name: String) { perform { try library?.addEntity("playlists",name:name); try refresh() } }
|
||||
func addToPlaylist(_ playlist: Int64, song: Int64) { perform { try library?.addToPlaylist(playlist,song:song); try refresh() } }
|
||||
func importFiles(_ urls: [URL]) { perform { guard let library else { throw LibraryError.message("Library unavailable") }; try Importer(media:root.appendingPathComponent("Media")).run(urls,library:library); try refresh() } }
|
||||
}
|
||||
@main struct KJamsCloneApp: App {
|
||||
@StateObject private var model = AppModel()
|
||||
var body: some Scene {
|
||||
Window("KJamsClone", id: "main") {
|
||||
LibraryView(model: model).frame(minWidth: 1060, minHeight: 680).preferredColorScheme(.dark)
|
||||
}.defaultSize(width: 1260, height: 840)
|
||||
.commands {
|
||||
CommandGroup(replacing: .newItem) {
|
||||
Button("New Singer…") { model.creating = .singer }.keyboardShortcut("n", modifiers: [.command, .shift])
|
||||
Button("New Venue…") { model.creating = .venue }.keyboardShortcut("n", modifiers: [.command, .option])
|
||||
}
|
||||
}
|
||||
Window("Video", id: "lyrics") {
|
||||
LyricsView(player: model.player).frame(minWidth: 480, minHeight: 320).preferredColorScheme(.dark)
|
||||
}.defaultSize(width: 600, height: 400)
|
||||
}
|
||||
}
|
||||
private enum Classic {
|
||||
static let frame = Color(red: 0.15, green: 0.15, blue: 0.15)
|
||||
static let navy = Color(red: 0.008, green: 0.065, blue: 0.16)
|
||||
static let blue = Color(red: 0.015, green: 0.17, blue: 0.42)
|
||||
static let header = Color(white: 0.115)
|
||||
static let line = Color(white: 0.42)
|
||||
}
|
||||
struct LyricsView: View {
|
||||
@ObservedObject var player: Player
|
||||
var body: some View {
|
||||
ZStack {
|
||||
Color.black
|
||||
if let image = player.image {
|
||||
Image(decorative: image, scale: 1).interpolation(.none).resizable().aspectRatio(1.5, contentMode: .fit)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/// This is another view of the same published CGImage used by the Video window.
|
||||
/// It owns no decoder, audio player or clock, so seeking/pause/tempo stay identical.
|
||||
private struct SidebarVideoMonitor: View {
|
||||
let player: Player
|
||||
var body: some View {
|
||||
VStack(alignment: .leading, spacing: 7) {
|
||||
Label("Video Monitor", systemImage: "tv")
|
||||
.font(.system(size: 11, weight: .medium)).foregroundStyle(.white.opacity(0.7))
|
||||
LyricsView(player: player)
|
||||
.aspectRatio(1.5, contentMode: .fit)
|
||||
.clipped()
|
||||
.overlay(Rectangle().strokeBorder(.white.opacity(0.25), lineWidth: 1))
|
||||
.accessibilityLabel("Video monitor, synchronized with the Video window")
|
||||
}.frame(maxWidth: .infinity)
|
||||
}
|
||||
}
|
||||
private struct SilverSquareStyle: ButtonStyle {
|
||||
func makeBody(configuration: Configuration) -> some View {
|
||||
configuration.label.foregroundStyle(Color(white: 0.25)).padding(.horizontal, 6).padding(.vertical, 3)
|
||||
.background(LinearGradient(colors: [Color(white: 0.95), Color(white: 0.64)], startPoint: .top, endPoint: .bottom), in: RoundedRectangle(cornerRadius: 4))
|
||||
.overlay(RoundedRectangle(cornerRadius: 4).strokeBorder(Color(white: 0.45), lineWidth: 1.5))
|
||||
.overlay(RoundedRectangle(cornerRadius: 3).strokeBorder(.white.opacity(0.7)).padding(3))
|
||||
.opacity(configuration.isPressed ? 0.7 : 1)
|
||||
}
|
||||
}
|
||||
private struct SilverButton: View {
|
||||
let symbol: String
|
||||
let label: String
|
||||
var size: CGFloat = 40
|
||||
var active = false
|
||||
var enabled = true
|
||||
let action: () -> Void
|
||||
var body: some View {
|
||||
Button(action: action) {
|
||||
Image(systemName: symbol).font(.system(size: size * 0.41, weight: .semibold))
|
||||
.foregroundStyle(active ? Color.blue : Color(white: 0.24))
|
||||
.frame(width: size, height: size)
|
||||
.background(LinearGradient(colors: [.white, Color(white: 0.85), Color(white: 0.63)], startPoint: .top, endPoint: .bottom), in: Circle())
|
||||
.overlay(Circle().strokeBorder(Color(white: 0.45), lineWidth: 1.5))
|
||||
.overlay(Circle().strokeBorder(.white.opacity(0.65), lineWidth: 1).padding(3))
|
||||
.shadow(color: .black.opacity(0.7), radius: 1, y: 1)
|
||||
}.buttonStyle(.plain).disabled(!enabled).opacity(enabled ? 1 : 0.72)
|
||||
.help(label).accessibilityLabel(label)
|
||||
}
|
||||
}
|
||||
struct LibraryView: View {
|
||||
@ObservedObject var model: AppModel
|
||||
@State private var selected: Int64?
|
||||
@State private var search = ""
|
||||
@State private var name = ""
|
||||
@State private var importing = false
|
||||
@State private var source = "Library"
|
||||
@Environment(\.openWindow) private var openWindow
|
||||
private var visibleSongs: [Song] { model.songs.filter { search.isEmpty || ($0.title+" "+$0.artist+" "+$0.album).localizedCaseInsensitiveContains(search) } }
|
||||
private var selectedSong: Song? { model.songs.first { $0.id == selected } }
|
||||
var body: some View {
|
||||
VStack(spacing: 0) {
|
||||
TransportView(player: model.player, search: $search, hasSelection: selectedSong != nil,
|
||||
play: playSelected, next: playNext, display: { openWindow(id: "lyrics") })
|
||||
.padding(.horizontal, 18).padding(.top, 18).padding(.bottom, 22)
|
||||
HSplitView {
|
||||
sidebar.frame(minWidth: 190, idealWidth: 220, maxWidth: 240)
|
||||
VStack(spacing: 12) {
|
||||
if source == "Library" { songTable }
|
||||
else if source == "Queue" { queuePane }
|
||||
else if source == "History" { historyPane }
|
||||
else if source == "Playlists" { playlistPane }
|
||||
else { directory }
|
||||
detailPanel.frame(height: 135)
|
||||
}.padding(.leading, 12).frame(minWidth: 780)
|
||||
}.padding(.horizontal, 18)
|
||||
footer.padding(.horizontal, 18).padding(.vertical, 12)
|
||||
}
|
||||
.background(Classic.frame)
|
||||
.sheet(item: $model.creating) { kind in
|
||||
AddEntitySheet(model: model, kind: kind) { id in
|
||||
if kind == .singer { model.selectedSinger = id } else { model.chooseVenue(id) }
|
||||
}
|
||||
}
|
||||
.fileImporter(isPresented: $importing, allowedContentTypes: [.audio, .zip, UTType(filenameExtension: "cdg") ?? .data], allowsMultipleSelection: true) { result in
|
||||
switch result {
|
||||
case .success(let urls): model.importFiles(urls)
|
||||
case .failure(let error): model.error = error.localizedDescription
|
||||
}
|
||||
}
|
||||
.alert("KJamsClone", isPresented: Binding(get: { model.error != nil }, set: { if !$0 { model.error = nil } })) {
|
||||
Button("OK") { model.error = nil }
|
||||
} message: { Text(model.error ?? "") }
|
||||
}
|
||||
private func sourceCount(_ source: String) -> Int {
|
||||
switch source {
|
||||
case "Library": return model.songs.count
|
||||
case "Singers": return model.venueSingers.count
|
||||
case "Venues": return model.venues.count
|
||||
case "Queue": return model.queue.count
|
||||
case "History": return model.history.count
|
||||
default: return model.playlists.count
|
||||
}
|
||||
}
|
||||
private var sidebar: some View {
|
||||
VStack(alignment: .leading, spacing: 0) {
|
||||
Text("Source").font(.system(size: 15, weight: .semibold)).padding(.horizontal, 10).frame(height: 31)
|
||||
.frame(maxWidth: .infinity, alignment: .leading).background(Classic.header)
|
||||
ForEach([("Library", "music.note.house.fill", Color.yellow), ("Singers", "person.2.fill", Color.green), ("Venues", "building.2.fill", Color.cyan), ("Queue", "list.number", Color.orange), ("History", "clock.arrow.circlepath", Color.purple), ("Playlists", "music.note.list", Color.mint)], id: \.0) { item in
|
||||
Button { source = item.0 } label: {
|
||||
HStack(spacing: 10) {
|
||||
Image(systemName: item.1).foregroundStyle(item.2).frame(width: 22)
|
||||
Text(item.0).font(.system(size: 16, weight: .medium))
|
||||
Spacer()
|
||||
Text("\(sourceCount(item.0))")
|
||||
.font(.system(size: 11)).foregroundStyle(.white.opacity(0.6))
|
||||
}.padding(.horizontal, 12).frame(height: 34).contentShape(Rectangle())
|
||||
.background(source == item.0 ? Color(red: 0, green: 0.36, blue: 1) : .clear)
|
||||
}.buttonStyle(.plain)
|
||||
}
|
||||
Spacer(minLength: 12)
|
||||
SidebarVideoMonitor(player: model.player).padding(10)
|
||||
}.foregroundStyle(.white).background(Classic.navy).overlay(Rectangle().stroke(Classic.line, lineWidth: 1))
|
||||
}
|
||||
private var songTable: some View {
|
||||
GeometryReader { geometry in
|
||||
ScrollView(.horizontal) {
|
||||
VStack(spacing: 0) {
|
||||
tableHeader(width: max(geometry.size.width, 790))
|
||||
ScrollView(.vertical) {
|
||||
LazyVStack(spacing: 0) {
|
||||
ForEach(visibleSongs) { song in songRow(song, width: max(geometry.size.width, 790)) }
|
||||
}.frame(maxWidth: .infinity, alignment: .topLeading)
|
||||
}
|
||||
}.frame(width: max(geometry.size.width, 790), height: geometry.size.height)
|
||||
}
|
||||
}.background(Classic.navy).overlay(Rectangle().stroke(Classic.line, lineWidth: 1))
|
||||
}
|
||||
private func widths(_ total: CGFloat) -> [CGFloat] {
|
||||
[42, max(200, total - 598), 100, 100, 76, 86, 72, 122]
|
||||
}
|
||||
private func tableHeader(width: CGFloat) -> some View {
|
||||
let sizes = widths(width)
|
||||
return HStack(spacing: 0) {
|
||||
ForEach(Array(["PLI", "Song Name", "Artist", "Album", "Label", "Key Adjust", "Tempo", "Rating"].enumerated()), id: \.offset) { index, title in
|
||||
Text(title).font(.system(size: 13, weight: .medium)).lineLimit(1)
|
||||
.padding(.leading, 7).frame(width: sizes[index], height: 30, alignment: .leading)
|
||||
.overlay(alignment: .trailing) { Rectangle().fill(Classic.line).frame(width: 1).padding(.vertical, 4) }
|
||||
}
|
||||
}.foregroundStyle(.white).background(Classic.header)
|
||||
.overlay(alignment: .bottom) { Rectangle().fill(Color(white: 0.65)).frame(height: 1) }
|
||||
}
|
||||
private func cellText(_ song: Song, column: Int) -> String {
|
||||
switch column {
|
||||
case 2: return song.artist.isEmpty ? "—" : song.artist
|
||||
case 3: return song.album.isEmpty ? "—" : song.album
|
||||
case 4: return song.label.isEmpty ? (song.cdg == nil ? "Audio" : URL(fileURLWithPath:song.audio).pathExtension.uppercased()+"+G") : song.label
|
||||
case 5: return String(format:"%+.0f",model.preference(song.id).pitch)
|
||||
default: return String(format:"%.0f%%",model.preference(song.id).tempo*100)
|
||||
}
|
||||
}
|
||||
private func songRow(_ song: Song, width: CGFloat) -> some View {
|
||||
let sizes = widths(width)
|
||||
return HStack(spacing: 0) {
|
||||
Image(systemName: song.cdg == nil ? "music.note" : "music.note.tv")
|
||||
.foregroundStyle(.white.opacity(0.75)).frame(width: sizes[0])
|
||||
Text(song.title).lineLimit(1).padding(.leading, 7).frame(width: sizes[1], alignment: .leading)
|
||||
ForEach(2..<7) { index in
|
||||
Text(cellText(song, column: index))
|
||||
.foregroundStyle(.white.opacity(0.5)).padding(.leading, 7).frame(width: sizes[index], alignment: .leading)
|
||||
}
|
||||
Menu {
|
||||
ForEach(0..<6) { value in
|
||||
Button(value == 0 ? "Unrated" : String(repeating: "★", count: value)) {
|
||||
model.perform { try model.library?.rate(song.id, value); try model.refresh() }
|
||||
}
|
||||
}
|
||||
} label: {
|
||||
Text(song.rating == 0 ? "☆☆☆☆☆" : String(repeating: "★", count: song.rating) + String(repeating: "☆", count: 5 - song.rating))
|
||||
.font(.system(size: 13)).foregroundStyle(song.rating == 0 ? Color.gray : Color.yellow)
|
||||
}.menuStyle(.borderlessButton).frame(width: sizes[7] - 14).padding(.horizontal, 7).help("Set song rating")
|
||||
}.font(.system(size: 13)).foregroundStyle(.white).frame(height: 30)
|
||||
.background(selected == song.id ? Color(red: 0, green: 0.28, blue: 0.72) : .clear)
|
||||
.contentShape(Rectangle()).onTapGesture(count: 2) { selected = song.id; playSelected() }
|
||||
.onTapGesture { selected = song.id }
|
||||
.contextMenu {
|
||||
Button("Play") { selected = song.id; playSelected() }
|
||||
Button("Add to Current Venue Queue") { model.enqueue(song.id) }.disabled(model.currentVenue == nil)
|
||||
Menu("Add to Playlist") { ForEach(model.playlists) { playlist in Button(playlist.name) { model.addToPlaylist(playlist.id,song:song.id) } } }
|
||||
}
|
||||
}
|
||||
@State private var managingRoster = false
|
||||
@State private var rosterNewName = ""
|
||||
@State private var editingEntity: PersonPlace?
|
||||
@State private var renameText = ""
|
||||
@State private var pendingDelete: PersonPlace?
|
||||
private var directory: some View {
|
||||
VStack(alignment:.leading,spacing:0) {
|
||||
HStack {
|
||||
Text(source == "Singers" ? "Singers · \(model.currentVenueName)" : "Venues").font(.headline)
|
||||
Spacer()
|
||||
if source == "Singers" { Button("Manage Venue Singers…") { managingRoster = true }.disabled(model.currentVenue == nil) }
|
||||
Button(source == "Singers" ? "New Singer…" : "New Venue…") { model.creating = source == "Singers" ? .singer : .venue }
|
||||
}.padding(12).background(Classic.header)
|
||||
ScrollView {
|
||||
VStack(alignment:.leading,spacing:0) {
|
||||
if source == "Singers" && model.venueSingers.isEmpty {
|
||||
Text("No singers at this venue. Add a singer or use Manage Venue Singers to include existing singers.").foregroundStyle(.secondary).padding()
|
||||
}
|
||||
ForEach(source == "Singers" ? model.venueSingers : model.venues) { entity in
|
||||
HStack {
|
||||
Button {
|
||||
if source == "Singers" { model.selectedSinger = entity.id } else { model.chooseVenue(entity.id) }
|
||||
} label: {
|
||||
HStack {
|
||||
Image(systemName:source == "Singers" ? "person.fill" : "building.2.fill")
|
||||
Text(entity.name); Spacer()
|
||||
if entity.id == (source == "Singers" ? model.selectedSinger : model.currentVenue) {
|
||||
Text(source == "Singers" ? "Selected" : "Current venue").font(.caption).foregroundStyle(.cyan)
|
||||
Image(systemName:"checkmark.circle.fill").foregroundStyle(.cyan)
|
||||
}
|
||||
}.contentShape(Rectangle())
|
||||
}.buttonStyle(.plain)
|
||||
Button("Rename") { renameText = entity.name; editingEntity = entity }
|
||||
Button("Delete",role:.destructive) { pendingDelete = entity }
|
||||
}.padding(12)
|
||||
}
|
||||
}
|
||||
}
|
||||
HStack {
|
||||
TextField(source == "Singers" ? "Singer name" : "Venue name",text:$name).textFieldStyle(.roundedBorder).onSubmit(addEntity)
|
||||
Button(source == "Singers" ? "Add Singer" : "Add Venue",action:addEntity).disabled(name.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty)
|
||||
}.padding(12)
|
||||
}.foregroundStyle(.white).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
|
||||
.sheet(isPresented:$managingRoster) { rosterSheet }
|
||||
.sheet(item:$editingEntity) { entity in
|
||||
VStack(alignment:.leading,spacing:16) {
|
||||
Text("Rename \(source == "Singers" ? "Singer" : "Venue")").font(.headline)
|
||||
TextField("Name",text:$renameText).textFieldStyle(.roundedBorder)
|
||||
HStack { Button("Cancel") { editingEntity = nil }; Spacer(); Button("Save") { model.rename(source == "Singers" ? "singers" : "venues",id:entity.id,name:renameText); editingEntity = nil }.disabled(renameText.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty) }
|
||||
}.padding(24).frame(width:360)
|
||||
}
|
||||
.confirmationDialog("Delete \(pendingDelete?.name ?? "entry")? Historical plays are kept. Venue memberships and queued entries for it will be removed.",isPresented:Binding(get:{ pendingDelete != nil },set:{ if !$0 { pendingDelete = nil } })) {
|
||||
Button("Delete",role:.destructive) { if let entity = pendingDelete { model.delete(source == "Singers" ? "singers" : "venues",id:entity.id) }; pendingDelete = nil }
|
||||
}
|
||||
}
|
||||
private var rosterSheet: some View {
|
||||
VStack(alignment:.leading,spacing:16) {
|
||||
Text("Singers at \(model.currentVenueName)").font(.title2.bold())
|
||||
Text("A singer can belong to any number of venues. Unchecking removes them from this venue only.").foregroundStyle(.secondary)
|
||||
ScrollView {
|
||||
VStack(alignment:.leading,spacing:12) {
|
||||
ForEach(model.singers) { singer in
|
||||
Toggle(singer.name,isOn:Binding(get:{ model.venueSingers.contains { $0.id == singer.id } },set:{ model.membership(singer:singer.id,included:$0) }))
|
||||
}
|
||||
}.frame(maxWidth:.infinity,alignment:.leading)
|
||||
}.frame(minHeight:120,maxHeight:280)
|
||||
HStack {
|
||||
TextField("New singer name",text:$rosterNewName).textFieldStyle(.roundedBorder)
|
||||
Button("Add") { model.perform { _ = try model.createEntity(.singer,name:rosterNewName); rosterNewName = "" } }.disabled(rosterNewName.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty)
|
||||
Spacer(); Button("Done") { managingRoster = false }.keyboardShortcut(.defaultAction)
|
||||
}
|
||||
}.padding(24).frame(width:460)
|
||||
}
|
||||
private var detailPanel: some View {
|
||||
VStack(alignment:.leading,spacing:9) {
|
||||
HStack(spacing:10) {
|
||||
Picker("Current venue",selection:Binding(get:{ model.currentVenue },set:{ model.chooseVenue($0) })) {
|
||||
Text("Select venue…").tag(nil as Int64?)
|
||||
ForEach(model.venues) { Text($0.name).tag(Optional($0.id)) }
|
||||
}
|
||||
Button { model.creating = .venue } label: { Image(systemName:"plus.circle.fill") }.buttonStyle(.plain).help("Add venue")
|
||||
Picker("Singer",selection:$model.selectedSinger) {
|
||||
Text("None").tag(nil as Int64?)
|
||||
ForEach(model.venueSingers) { Text($0.name).tag(Optional($0.id)) }
|
||||
}
|
||||
Button { model.creating = .singer } label: { Image(systemName:"plus.circle.fill") }.buttonStyle(.plain).help("Add singer")
|
||||
Button("Queue Song") { if let selected { model.enqueue(selected) } }.disabled(selected == nil || model.currentVenue == nil)
|
||||
}
|
||||
PlaybackSettings(player:model.player,model:model,selectedSong:selected)
|
||||
SeekBar(player:model.player)
|
||||
}.padding(12).frame(maxWidth:.infinity,maxHeight:.infinity)
|
||||
.background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
|
||||
}
|
||||
@State private var playlistName = ""
|
||||
@State private var selectedPlaylist: Int64?
|
||||
private var queuePane: some View {
|
||||
VStack(alignment:.leading,spacing:12) {
|
||||
HStack { Text("Queue · \(model.currentVenueName)").font(.headline); Spacer(); Toggle("Auto play next",isOn:$model.autoAdvance).toggleStyle(.checkbox); Button("Play Next") { model.playQueueNext() }.disabled(model.queue.isEmpty) }
|
||||
ScrollView {
|
||||
VStack(spacing:0) {
|
||||
ForEach(Array(model.queue.enumerated()),id:\.element.id) { index,row in
|
||||
HStack {
|
||||
Text("\(index+1)").foregroundStyle(.secondary).frame(width:24)
|
||||
Text(row.singer).frame(width:140,alignment:.leading)
|
||||
Text(row.title).lineLimit(1); Spacer()
|
||||
Button { model.moveQueue(row.id,by:-1) } label: { Image(systemName:"arrow.up") }.disabled(index == 0)
|
||||
Button { model.moveQueue(row.id,by:1) } label: { Image(systemName:"arrow.down") }.disabled(index == model.queue.count-1)
|
||||
Button("Remove") { model.removeQueue(row.id) }
|
||||
}.padding(.vertical,8)
|
||||
}
|
||||
if model.queue.isEmpty { Text("Choose a venue and singer, select a library song, then click Queue Song.").foregroundStyle(.secondary).padding(.top,30) }
|
||||
}
|
||||
}
|
||||
}.padding(14).frame(maxWidth:.infinity,maxHeight:.infinity).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
|
||||
}
|
||||
@State private var historyAllVenues = false
|
||||
private var displayedHistory: [Performance] {
|
||||
if historyAllVenues { return (try? model.library?.history(venue:nil,singer:model.selectedSinger)) ?? [] }
|
||||
return model.history.filter { model.selectedSinger == nil || $0.singer == model.singers.first(where: { $0.id == model.selectedSinger })?.name }
|
||||
}
|
||||
private var historyPane: some View {
|
||||
VStack(alignment:.leading,spacing:12) {
|
||||
HStack { Text("History · \(historyAllVenues || model.currentVenue == nil ? "All venues" : model.currentVenueName)").font(.headline); Spacer(); Toggle("All venues",isOn:$historyAllVenues).toggleStyle(.checkbox) }
|
||||
ScrollView {
|
||||
LazyVStack(alignment:.leading,spacing:12) {
|
||||
ForEach(displayedHistory) { row in
|
||||
HStack { Text(row.date).font(.system(.caption,design:.monospaced)); Text(row.singer).frame(width:130,alignment:.leading); Text(row.song); Spacer(); Text(row.venue).foregroundStyle(.secondary) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}.padding(14).frame(maxWidth:.infinity,maxHeight:.infinity).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
|
||||
}
|
||||
private var playlistPane: some View {
|
||||
VStack(alignment:.leading,spacing:12) {
|
||||
HStack {
|
||||
Picker("Playlist",selection:$selectedPlaylist) { Text("Choose…").tag(nil as Int64?); ForEach(model.playlists) { Text($0.name).tag(Optional($0.id)) } }
|
||||
TextField("New playlist name",text:$playlistName).textFieldStyle(.roundedBorder)
|
||||
Button("Create") { model.createPlaylist(playlistName); selectedPlaylist = model.playlists.first { $0.name == playlistName.trimmingCharacters(in:.whitespacesAndNewlines) }?.id; playlistName = "" }.disabled(playlistName.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty)
|
||||
if let selectedPlaylist {
|
||||
Button("Rename") { model.rename("playlists",id:selectedPlaylist,name:playlistName); playlistName = "" }.disabled(playlistName.trimmingCharacters(in:.whitespacesAndNewlines).isEmpty)
|
||||
Button("Delete",role:.destructive) { model.delete("playlists",id:selectedPlaylist); self.selectedPlaylist = nil } }
|
||||
}
|
||||
ScrollView {
|
||||
if let selectedPlaylist {
|
||||
let ids = (try? model.library?.playlistSongIDs(selectedPlaylist)) ?? []
|
||||
VStack(alignment:.leading,spacing:10) {
|
||||
ForEach(ids,id:\.self) { id in
|
||||
if let song = model.songs.first(where: { $0.id == id }) {
|
||||
HStack {
|
||||
Text(song.title); Spacer()
|
||||
Button("Play") { model.perform { try model.play(song) } }
|
||||
Button("Queue") { model.enqueue(song.id) }.disabled(model.currentVenue == nil)
|
||||
Button("Remove") { model.perform { try model.library?.removeFromPlaylist(selectedPlaylist,song:id); try model.refresh() } }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Text("Add songs using the library row’s context menu.").foregroundStyle(.secondary).padding(.top,20)
|
||||
}
|
||||
}.padding(14).frame(maxWidth:.infinity,maxHeight:.infinity).background(Classic.navy).overlay(Rectangle().stroke(Classic.line))
|
||||
}
|
||||
private var footer: some View {
|
||||
HStack {
|
||||
Button { importing = true } label: { Image(systemName: "plus").font(.system(size: 20, weight: .bold)).frame(width: 32, height: 24) }
|
||||
.help("Import audio, MP3+G or ZIP").accessibilityLabel("Import songs")
|
||||
RepeatButton(player: model.player).padding(.leading, 12)
|
||||
Spacer()
|
||||
Text("\(visibleSongs.count) \(visibleSongs.count == 1 ? "Song" : "Songs")").font(.system(size: 14, weight: .medium))
|
||||
Spacer()
|
||||
Button { openWindow(id: "lyrics") } label: { Image(systemName: "rectangle.on.rectangle").frame(width: 32, height: 24) }
|
||||
.help("Open video window").accessibilityLabel("Open video window")
|
||||
}.buttonStyle(SilverSquareStyle())
|
||||
}
|
||||
private func playSelected() {
|
||||
guard let song = selectedSong else { return }
|
||||
model.perform { try model.play(song) }
|
||||
}
|
||||
private func playNext() {
|
||||
guard !visibleSongs.isEmpty else { return }
|
||||
let index = visibleSongs.firstIndex { $0.id == selected } ?? -1
|
||||
selected = visibleSongs[(index + 1) % visibleSongs.count].id; playSelected()
|
||||
}
|
||||
private func addEntity() {
|
||||
model.perform {
|
||||
let kind: EntityKind = source == "Singers" ? .singer : .venue
|
||||
let id = try model.createEntity(kind, name: name)
|
||||
if kind == .singer { model.selectedSinger = id } else { model.chooseVenue(id) }
|
||||
name = ""
|
||||
}
|
||||
}
|
||||
}
|
||||
private struct AddEntitySheet: View {
|
||||
@ObservedObject var model: AppModel
|
||||
let kind: EntityKind
|
||||
let saved: (Int64) -> Void
|
||||
@Environment(\.dismiss) private var dismiss
|
||||
@State private var name = ""
|
||||
@State private var error: String?
|
||||
@FocusState private var focused: Bool
|
||||
var body: some View {
|
||||
VStack(alignment: .leading, spacing: 16) {
|
||||
Text("New \(kind.title)").font(.title2.bold())
|
||||
TextField("\(kind.title) name", text: $name).textFieldStyle(.roundedBorder)
|
||||
.focused($focused).onSubmit(save)
|
||||
if let error { Text(error).foregroundStyle(.red).font(.callout) }
|
||||
HStack {
|
||||
Spacer()
|
||||
Button("Cancel") { dismiss() }.keyboardShortcut(.cancelAction)
|
||||
Button("Add \(kind.title)", action: save).keyboardShortcut(.defaultAction)
|
||||
.disabled(name.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
|
||||
}
|
||||
}.padding(24).frame(width: 360).onAppear { focused = true }
|
||||
}
|
||||
private func save() {
|
||||
do { let id = try model.createEntity(kind, name: name); saved(id); dismiss() }
|
||||
catch { self.error = error.localizedDescription }
|
||||
}
|
||||
}
|
||||
private struct TransportView: View {
|
||||
@ObservedObject var player: Player
|
||||
@Binding var search: String
|
||||
let hasSelection: Bool
|
||||
let play: () -> Void
|
||||
let next: () -> Void
|
||||
let display: () -> Void
|
||||
var body: some View {
|
||||
HStack(alignment: .top, spacing: 28) {
|
||||
VStack(spacing: 15) {
|
||||
HStack(spacing: 7) {
|
||||
SilverButton(symbol: "backward.fill", label: "Back 10 seconds", size: 35, enabled: player.duration > 0) { player.seek(player.time - 10) }
|
||||
SilverButton(symbol: player.playing ? "pause.fill" : "play.fill", label: player.playing ? "Pause" : "Play", size: 49, enabled: hasSelection || player.duration > 0) {
|
||||
if player.duration > 0 { player.toggle() } else { play() }
|
||||
}
|
||||
SilverButton(symbol: "stop", label: "Stop", size: 46, enabled: player.duration > 0) { player.stop() }
|
||||
SilverButton(symbol: "forward.fill", label: "Forward 10 seconds", size: 35, enabled: player.duration > 0) { player.seek(player.time + 10) }
|
||||
SilverButton(symbol: "forward.end.fill", label: "Play next song", size: 26, enabled: hasSelection, action: next)
|
||||
}
|
||||
HStack(spacing: 9) {
|
||||
Image(systemName: "speaker.fill").font(.system(size: 11))
|
||||
Slider(value: $player.volume, in: 0...1).controlSize(.small).tint(.gray).accessibilityLabel("Volume")
|
||||
Image(systemName: "speaker.wave.3.fill").font(.system(size: 12))
|
||||
}.frame(width: 180)
|
||||
}.frame(width: 220)
|
||||
VStack(spacing: 0) {
|
||||
Text(player.duration == 0 ? "Ready!" : player.title).font(.system(size: 15, weight: .medium)).lineLimit(1).padding(.horizontal, 20)
|
||||
if player.duration > 0 { Text(player.playing ? "Playing" : "Paused").font(.system(size: 10)).foregroundStyle(.white.opacity(0.65)).padding(.top, 4) }
|
||||
}.frame(maxWidth: .infinity).frame(height: 64)
|
||||
.background(LinearGradient(colors: [Color(red: 0, green: 0.10, blue: 0.30), Classic.blue], startPoint: .top, endPoint: .bottom), in: Capsule())
|
||||
.overlay(Capsule().strokeBorder(LinearGradient(colors: [.black, .white], startPoint: .top, endPoint: .bottom), lineWidth: 1.5))
|
||||
.padding(.top, 14)
|
||||
HStack(spacing: 12) {
|
||||
TextField("Search", text: $search).textFieldStyle(.plain).font(.system(size: 16))
|
||||
.padding(.horizontal, 8).frame(width: 145, height: 28).background(Color(white: 0.07), in: RoundedRectangle(cornerRadius: 5))
|
||||
.overlay(RoundedRectangle(cornerRadius: 5).stroke(.white.opacity(0.1)))
|
||||
SilverButton(symbol: "eye", label: "Open video window", size: 48, action: display)
|
||||
}.padding(.top, 15)
|
||||
}.foregroundStyle(.white).frame(height: 96)
|
||||
}
|
||||
}
|
||||
private struct PlaybackSettings: View {
|
||||
@ObservedObject var player: Player
|
||||
@ObservedObject var model: AppModel
|
||||
let selectedSong: Int64?
|
||||
@State private var personalRating = 0
|
||||
var body: some View {
|
||||
HStack(spacing:10) {
|
||||
Text("Key")
|
||||
Picker("Key",selection:$player.pitch) { ForEach(-12..<13) { Text(String(format:"%+d",$0)).tag(Double($0)) } }.labelsHidden().frame(width:70)
|
||||
Text("Tempo")
|
||||
Slider(value:$player.tempo,in:0.5...1.5,step:0.05).frame(width:85)
|
||||
Text(String(format:"%.0f%%",player.tempo*100)).monospacedDigit().frame(width:40)
|
||||
Text("Rating")
|
||||
Picker("Singer rating",selection:$personalRating) { ForEach(0..<6) { Text($0 == 0 ? "Unrated" : String(repeating:"★",count:$0)).tag($0) } }.labelsHidden().frame(width:88).help("Singer-specific song rating")
|
||||
Button("Save for Singer") {
|
||||
if let song = player.currentSongID ?? selectedSong { model.savePreference(song:song,value:.init(pitch:player.pitch,tempo:player.tempo,rating:personalRating)) }
|
||||
}.disabled(model.selectedSinger == nil || (player.currentSongID == nil && selectedSong == nil))
|
||||
Menu {
|
||||
Button("Reset key / tempo") { player.pitch = 0; player.tempo = 1 }
|
||||
ForEach([-1.0,-0.5,0,0.5,1.0],id:\.self) { offset in Button(String(format:"Graphics offset %+.1fs",offset)) { player.graphicsOffset = offset } }
|
||||
} label: { Image(systemName:"slider.horizontal.3") }.menuStyle(.borderlessButton).frame(width:22).help("Playback settings")
|
||||
}.font(.system(size:11))
|
||||
.onChange(of:model.selectedSinger) { _ in loadRating() }
|
||||
.onChange(of:player.currentSongID) { _ in loadRating() }
|
||||
.onChange(of:selectedSong) { _ in loadRating() }
|
||||
}
|
||||
private func loadRating() { if let song = player.currentSongID ?? selectedSong { personalRating = model.preference(song).rating } else { personalRating = 0 } }
|
||||
}
|
||||
private struct SeekBar: View {
|
||||
@ObservedObject var player: Player
|
||||
private func clock(_ seconds: Double) -> String { let n = Int(seconds); return String(format: "%d:%02d", n / 60, n % 60) }
|
||||
var body: some View {
|
||||
HStack(spacing: 10) {
|
||||
Text(clock(player.time))
|
||||
Slider(value: Binding(get: { player.time }, set: { player.seek($0) }), in: 0...max(1, player.duration))
|
||||
.controlSize(.mini).tint(.gray).disabled(player.duration == 0).accessibilityLabel("Playback position")
|
||||
Text(clock(player.duration))
|
||||
}.font(.system(size: 10, design: .monospaced)).foregroundStyle(.white.opacity(0.65))
|
||||
}
|
||||
}
|
||||
private struct RepeatButton: View {
|
||||
@ObservedObject var player: Player
|
||||
var body: some View {
|
||||
Button { player.repeating.toggle() } label: {
|
||||
Image(systemName: "repeat").font(.system(size: 18, weight: .semibold))
|
||||
.foregroundStyle(player.repeating ? Color.blue : Color(white: 0.25)).frame(width: 32, height: 24)
|
||||
}.help(player.repeating ? "Repeat song: on" : "Repeat song: off").accessibilityLabel("Repeat song").accessibilityValue(player.repeating ? "On" : "Off")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
import SwiftUI
|
||||
import AVFoundation
|
||||
|
||||
/// CDG follows consumed source frames, so tempo adjustment preserves graphics timing.
|
||||
@MainActor final class Player: ObservableObject {
|
||||
@Published var image: CGImage?
|
||||
@Published var playing = false
|
||||
@Published var time: Double = 0
|
||||
@Published var duration: Double = 0
|
||||
@Published var title = "Select a song"
|
||||
@Published var volume: Double = 0.8 { didSet { engine.mainMixerNode.outputVolume = Float(volume) } }
|
||||
@Published var repeating = false
|
||||
@Published var pitch: Double = 0 { didSet { effect.pitch = Float(pitch * 100) } }
|
||||
@Published var tempo: Double = 1 { didSet { effect.rate = Float(tempo) } }
|
||||
@Published var graphicsOffset: Double = 0
|
||||
private(set) var currentSongID: Int64?
|
||||
var onFinished: (() -> Void)?
|
||||
private let engine = AVAudioEngine()
|
||||
private let node = AVAudioPlayerNode()
|
||||
private let effect = AVAudioUnitTimePitch()
|
||||
private var file: AVAudioFile?
|
||||
private var anchor: Double = 0
|
||||
private var generation = UUID()
|
||||
private var cdg = Data()
|
||||
private var decoder = CDGDecoder()
|
||||
private var timer: Timer?
|
||||
init() { engine.attach(node); engine.attach(effect) }
|
||||
func load(_ song: Song, preference: SongPreference = .init()) throws {
|
||||
stop()
|
||||
do {
|
||||
let loaded = try AVAudioFile(forReading:URL(fileURLWithPath:song.audio))
|
||||
let graphics = try song.cdg.map { try Data(contentsOf:URL(fileURLWithPath:$0)) } ?? Data()
|
||||
guard loaded.length > 0 else { throw LibraryError.message("Audio file is empty") }
|
||||
engine.connect(node,to:effect,format:loaded.processingFormat)
|
||||
engine.connect(effect,to:engine.mainMixerNode,format:loaded.processingFormat)
|
||||
file = loaded; cdg = graphics; decoder = CDGDecoder()
|
||||
duration = Double(loaded.length)/loaded.processingFormat.sampleRate
|
||||
title = song.title; currentSongID = song.id
|
||||
pitch = preference.pitch; tempo = preference.tempo
|
||||
engine.mainMixerNode.outputVolume = Float(volume)
|
||||
engine.prepare(); try engine.start()
|
||||
schedule(at:0,play:true); startTimer(); tick()
|
||||
} catch { stop(); throw error }
|
||||
}
|
||||
private func schedule(at seconds: Double, play: Bool) {
|
||||
guard let file else { return }
|
||||
generation = UUID(); let token = generation
|
||||
node.stop()
|
||||
let rate = file.processingFormat.sampleRate
|
||||
let start = min(file.length,max(0,AVAudioFramePosition(seconds*rate)))
|
||||
anchor = Double(start)/rate; time = anchor
|
||||
guard start < file.length else { playing = false; render(); return }
|
||||
node.scheduleSegment(file,startingFrame:start,frameCount:AVAudioFrameCount(min(file.length-start,Int64(UInt32.max))),at:nil,completionCallbackType:.dataPlayedBack) { [weak self] _ in
|
||||
Task { @MainActor in
|
||||
guard let self, self.generation == token else { return }
|
||||
if self.repeating { self.schedule(at:0,play:true) }
|
||||
else {
|
||||
self.playing = false; self.time = self.duration; self.render()
|
||||
self.timer?.invalidate(); self.timer = nil; self.onFinished?()
|
||||
}
|
||||
}
|
||||
}
|
||||
if play { node.play() }; playing = play; render()
|
||||
}
|
||||
private func startTimer() {
|
||||
timer?.invalidate()
|
||||
timer = Timer.scheduledTimer(withTimeInterval:1.0/30,repeats:true) { [weak self] _ in Task { @MainActor in self?.tick() } }
|
||||
}
|
||||
func toggle() {
|
||||
guard file != nil else { return }
|
||||
if playing { tick(); node.pause(); playing = false }
|
||||
else if time >= duration { schedule(at:0,play:true); startTimer() }
|
||||
else { node.play(); playing = true; startTimer() }
|
||||
}
|
||||
func stop() {
|
||||
generation = UUID(); timer?.invalidate(); timer = nil; node.stop(); engine.stop()
|
||||
engine.disconnectNodeOutput(node); engine.disconnectNodeOutput(effect)
|
||||
file = nil; playing = false; time = 0; anchor = 0; duration = 0; image = nil; currentSongID = nil; title = "Select a song"
|
||||
}
|
||||
func seek(_ value: Double) {
|
||||
guard file != nil, value.isFinite else { return }
|
||||
schedule(at:min(max(value,0),duration),play:playing); startTimer()
|
||||
}
|
||||
private func render() { decoder.render(cdg,at:max(0,time+graphicsOffset)); image = cdg.isEmpty ? nil : decoder.image() }
|
||||
private func tick() {
|
||||
if playing, let file, let renderTime = node.lastRenderTime, let playerTime = node.playerTime(forNodeTime:renderTime) {
|
||||
time = min(duration,max(0,anchor+Double(playerTime.sampleTime)/file.processingFormat.sampleRate))
|
||||
}
|
||||
render()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,229 @@
|
||||
import XCTest
|
||||
@testable import KJamsClone
|
||||
|
||||
final class KJamsCloneTests: XCTestCase {
|
||||
func packet(_ instruction: UInt8, _ data: [UInt8]) -> [UInt8] { [9,instruction,0,0] + Array((data + Array(repeating: 0,count:16)).prefix(16)) + [0,0,0,0] }
|
||||
func testPresetTileXORAndInvalidCoordinates() {
|
||||
var d = CDGDecoder()
|
||||
d.apply(packet(1,[3,0])); XCTAssertEqual(d.pixels[0],3)
|
||||
d.apply(packet(6,[0,5,1,1] + Array(repeating:63,count:12)))
|
||||
XCTAssertEqual(d.pixels[12*300+6],5)
|
||||
d.apply(packet(38,[0,5,1,1] + Array(repeating:63,count:12)))
|
||||
XCTAssertEqual(d.pixels[12*300+6],0)
|
||||
let old = d.pixels; d.apply(packet(6,[1,2,31,63])); XCTAssertEqual(d.pixels,old)
|
||||
}
|
||||
func testSeekAndTruncatedPacket() {
|
||||
var d = CDGDecoder()
|
||||
let data = Data(packet(1,[2,0]) + packet(1,[7,0]) + [9])
|
||||
d.render(data,at:1); XCTAssertEqual(d.pixels[0],7); XCTAssertEqual(d.packetIndex,2)
|
||||
d.render(data,at:1.0/300); XCTAssertEqual(d.pixels[0],2)
|
||||
d.render(data,at:0); XCTAssertEqual(d.pixels[0],0)
|
||||
}
|
||||
func testPaletteBorderScrollAndImage() {
|
||||
var d = CDGDecoder()
|
||||
d.apply(packet(30,[63,63])); XCTAssertEqual(d.palette[0],0xFFFFFFFF)
|
||||
d.apply(packet(2,[4])); XCTAssertEqual(d.pixels[0],4); XCTAssertEqual(d.pixels[12*300+6],0)
|
||||
d.apply(packet(20,[3,16,0])); XCTAssertEqual(d.pixels[100*300],3)
|
||||
d.apply(packet(24,[0,32,0])); XCTAssertEqual(d.pixels[100*300+294],3)
|
||||
XCTAssertEqual(d.image()?.width,288)
|
||||
}
|
||||
func testSQLitePersistenceDedupRatingsAndHistory() throws {
|
||||
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at: folder,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:folder) }
|
||||
let url = folder.appendingPathComponent("test.sqlite")
|
||||
do {
|
||||
let db = try Library(url:url)
|
||||
try db.add(title:"Singer's Song",audio:"/test.mp3",cdg:nil)
|
||||
try db.add(title:"Duplicate",audio:"/test.mp3",cdg:"/test.cdg")
|
||||
let song = try XCTUnwrap(db.songs().first)
|
||||
try db.rate(song.id,5); XCTAssertThrowsError(try db.rate(song.id,6))
|
||||
try db.addEntity("singers",name:"O'Neil"); try db.addEntity("venues",name:"Hall")
|
||||
try db.record(song.id,singer:db.entities("singers").first?.id,venue:db.entities("venues").first?.id)
|
||||
}
|
||||
let reopened = try Library(url:url); let songs = try reopened.songs()
|
||||
XCTAssertEqual(songs.count,1); XCTAssertEqual(songs[0].rating,5); XCTAssertEqual(songs[0].plays,1); XCTAssertEqual(songs[0].cdg,"/test.cdg")
|
||||
XCTAssertEqual(try reopened.entities("singers").first?.name,"O'Neil")
|
||||
}
|
||||
func testPairedImportAndContentDedup() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let audio = root.appendingPathComponent("Test.mp3"), cdg = root.appendingPathComponent("Test.CDG")
|
||||
try Data([1,2,3]).write(to:audio); try Data(packet(1,[2,0])).write(to:cdg)
|
||||
let db = try Library(url:root.appendingPathComponent("test.sqlite"))
|
||||
let importer = Importer(media:root.appendingPathComponent("Media"))
|
||||
try importer.run([audio],library:db); try importer.run([audio],library:db)
|
||||
XCTAssertEqual(try db.songs().count,1)
|
||||
XCTAssertNotNil(try db.songs().first?.cdg)
|
||||
}
|
||||
|
||||
func testZippedMP3GImportAndUnsafeArchiveRejection() throws {
|
||||
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:folder,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:folder) }
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
let db = try Library(url:folder.appendingPathComponent("db.sqlite"))
|
||||
let importer = Importer(media:folder.appendingPathComponent("Media"))
|
||||
try importer.run([fixtures.appendingPathComponent("Demo.zip")],library:db)
|
||||
let song = try XCTUnwrap(db.songs().first)
|
||||
XCTAssertEqual(song.title,"Demo"); XCTAssertNotNil(song.cdg)
|
||||
XCTAssertTrue(FileManager.default.fileExists(atPath:song.audio))
|
||||
XCTAssertThrowsError(try importer.run([fixtures.appendingPathComponent("Unsafe.zip")],library:db))
|
||||
}
|
||||
@MainActor func testMP3PlaybackPauseAndSeek() throws {
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
let player = Player()
|
||||
defer { player.stop() }
|
||||
try player.load(Song(id:1,title:"Demo",audio:fixtures.appendingPathComponent("Demo.mp3").path,cdg:fixtures.appendingPathComponent("Demo.cdg").path,rating:0,plays:0))
|
||||
XCTAssertGreaterThan(player.duration,3.9); XCTAssertTrue(player.playing)
|
||||
player.toggle(); XCTAssertFalse(player.playing)
|
||||
player.seek(2); XCTAssertEqual(player.time,2,accuracy:0.05); XCTAssertNotNil(player.image)
|
||||
player.seek(0.1); XCTAssertEqual(player.time,0.1,accuracy:0.05)
|
||||
}
|
||||
@MainActor func testCreateSingerAndVenueThroughAppModel() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let model = AppModel(storageURL: root)
|
||||
XCTAssertNil(model.error)
|
||||
let singer = try model.createEntity(.singer, name: " Alex ")
|
||||
let venue = try model.createEntity(.venue, name: "Town Hall")
|
||||
XCTAssertEqual(model.singers.first?.name, "Alex")
|
||||
XCTAssertEqual(model.venues.first?.name, "Town Hall")
|
||||
XCTAssertEqual(try model.createEntity(.singer, name: "Alex"), singer)
|
||||
XCTAssertEqual(model.singers.count, 1)
|
||||
XCTAssertThrowsError(try model.createEntity(.venue, name: " "))
|
||||
let reopened = AppModel(storageURL: root)
|
||||
XCTAssertEqual(reopened.singers.first?.id, singer)
|
||||
XCTAssertEqual(reopened.venues.first?.id, venue)
|
||||
}
|
||||
|
||||
@MainActor func testVenuesShareSingersAndRememberSelection() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let model = AppModel(storageURL:root)
|
||||
let hall = try model.createEntity(.venue,name:"Hall")
|
||||
let alex = try model.createEntity(.singer,name:"Alex")
|
||||
let club = try model.createEntity(.venue,name:"Club")
|
||||
XCTAssertTrue(model.venueSingers.isEmpty)
|
||||
model.membership(singer:alex,included:true)
|
||||
XCTAssertEqual(model.venueSingers.map(\.id),[alex])
|
||||
model.chooseVenue(hall); XCTAssertEqual(model.venueSingers.map(\.id),[alex])
|
||||
model.chooseVenue(club); model.membership(singer:alex,included:false)
|
||||
XCTAssertTrue(model.venueSingers.isEmpty)
|
||||
let reopened = AppModel(storageURL:root)
|
||||
XCTAssertEqual(reopened.currentVenue,club); XCTAssertTrue(reopened.venueSingers.isEmpty)
|
||||
reopened.chooseVenue(hall); XCTAssertEqual(reopened.venueSingers.map(\.id),[alex])
|
||||
XCTAssertEqual(reopened.singers.count,1)
|
||||
}
|
||||
func testMigrationAndMembershipRemovalDoesNotReappear() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let url = root.appendingPathComponent("db.sqlite")
|
||||
var singer: Int64 = 0, venue: Int64 = 0
|
||||
do {
|
||||
let db = try Library(url:url)
|
||||
try db.add(title:"Song",audio:"/a.mp3",cdg:nil)
|
||||
try db.addEntity("singers",name:"Alex"); try db.addEntity("venues",name:"Hall")
|
||||
singer = try XCTUnwrap(db.entities("singers").first?.id); venue = try XCTUnwrap(db.entities("venues").first?.id)
|
||||
try db.record(XCTUnwrap(db.songs().first?.id),singer:singer,venue:venue)
|
||||
try db.execute("PRAGMA user_version=1")
|
||||
}
|
||||
do {
|
||||
let migrated = try Library(url:url)
|
||||
XCTAssertEqual(try migrated.members(of:venue).map(\.id),[singer])
|
||||
try migrated.setMembership(singer:singer,venue:venue,included:false)
|
||||
}
|
||||
let reopened = try Library(url:url)
|
||||
XCTAssertTrue(try reopened.members(of:venue).isEmpty)
|
||||
XCTAssertEqual(try reopened.history(venue:venue).count,1)
|
||||
}
|
||||
func testQueuePlaylistsPreferencesAndDeletion() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let db = try Library(url:root.appendingPathComponent("db.sqlite"))
|
||||
try db.add(title:"First",audio:"/1.mp3",cdg:nil)
|
||||
try db.add(title:"Second",audio:"/2.mp3",cdg:nil)
|
||||
let songs = try db.songs()
|
||||
try db.addEntity("singers",name:"Alex"); try db.addEntity("venues",name:"Hall"); try db.addEntity("venues",name:"Club")
|
||||
let singer = try XCTUnwrap(db.entities("singers").first?.id)
|
||||
let hall = try XCTUnwrap(db.entities("venues").first(where: { $0.name == "Hall" })?.id)
|
||||
let club = try XCTUnwrap(db.entities("venues").first(where: { $0.name == "Club" })?.id)
|
||||
XCTAssertThrowsError(try db.enqueue(song:songs[0].id,singer:singer,venue:hall))
|
||||
try db.setMembership(singer:singer,venue:hall,included:true)
|
||||
try db.enqueue(song:songs[0].id,singer:singer,venue:hall); try db.enqueue(song:songs[1].id,singer:singer,venue:hall)
|
||||
XCTAssertTrue(try db.queue(venue:club).isEmpty)
|
||||
let second = try XCTUnwrap(db.queue(venue:hall).last)
|
||||
try db.moveQueue(second.id,venue:hall,by:-1)
|
||||
XCTAssertEqual(try db.queue(venue:hall).first?.songID,songs[1].id)
|
||||
let preference = SongPreference(pitch:3,tempo:0.85,rating:4)
|
||||
try db.savePreference(song:songs[0].id,singer:singer,value:preference)
|
||||
XCTAssertEqual(try db.preference(song:songs[0].id,singer:singer),preference)
|
||||
XCTAssertThrowsError(try db.savePreference(song:songs[0].id,singer:singer,value:.init(pitch:99)))
|
||||
try db.addEntity("playlists",name:"Party")
|
||||
let playlist = try XCTUnwrap(db.entities("playlists").first?.id)
|
||||
try db.addToPlaylist(playlist,song:songs[0].id); try db.addToPlaylist(playlist,song:songs[0].id)
|
||||
XCTAssertEqual(try db.playlistSongIDs(playlist),[songs[0].id])
|
||||
try db.record(songs[0].id,singer:singer,venue:hall)
|
||||
try db.rename("singers",id:singer,name:"Alex Jones")
|
||||
XCTAssertEqual(try db.history(venue:hall).first?.singer,"Alex Jones")
|
||||
try db.deleteEntity("singers",id:singer)
|
||||
XCTAssertTrue(try db.queue(venue:hall).isEmpty)
|
||||
XCTAssertEqual(try db.history(venue:hall).count,1)
|
||||
try db.selectVenue(hall); try db.deleteEntity("venues",id:hall)
|
||||
XCTAssertNil(try db.currentVenue()); XCTAssertEqual(try db.history(venue:nil).count,1)
|
||||
}
|
||||
@MainActor func testTempoSourceClockPauseAndResume() async throws {
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
let player = Player(); defer { player.stop() }
|
||||
let song = Song(id:1,title:"Demo",audio:fixtures.appendingPathComponent("Demo.mp3").path,cdg:fixtures.appendingPathComponent("Demo.cdg").path,rating:0,plays:0)
|
||||
try player.load(song,preference:.init(pitch:2,tempo:1.5,rating:3))
|
||||
XCTAssertEqual(player.pitch,2); XCTAssertEqual(player.tempo,1.5)
|
||||
try await Task.sleep(nanoseconds:500_000_000)
|
||||
XCTAssertGreaterThan(player.time,0.45); XCTAssertLessThan(player.time,1.3)
|
||||
player.toggle(); let paused = player.time
|
||||
try await Task.sleep(nanoseconds:100_000_000)
|
||||
XCTAssertEqual(player.time,paused,accuracy:0.025)
|
||||
player.seek(1.5); player.toggle()
|
||||
try await Task.sleep(nanoseconds:200_000_000)
|
||||
XCTAssertGreaterThan(player.time,1.6); XCTAssertNotNil(player.image)
|
||||
}
|
||||
func testNewTestMediaMetadataAndCDGPairImport() throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let db = try Library(url:root.appendingPathComponent("db.sqlite"))
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
let importer = Importer(media:root.appendingPathComponent("Media"))
|
||||
try importer.run([fixtures.appendingPathComponent("TestTrack.cdg")],library:db)
|
||||
let song = try XCTUnwrap(db.songs().first)
|
||||
XCTAssertEqual(song.title,"MP3 Plus G Test")
|
||||
XCTAssertEqual(song.artist,"KJamsClone Test Generator")
|
||||
XCTAssertNotNil(song.cdg)
|
||||
let bytes = try Data(contentsOf:fixtures.appendingPathComponent("TestTrack.cdg"))
|
||||
XCTAssertEqual(bytes.count,20*300*24)
|
||||
var decoder = CDGDecoder(); decoder.render(bytes,at:2)
|
||||
XCTAssertTrue(decoder.pixels.contains(1)); XCTAssertTrue(decoder.pixels.contains(2))
|
||||
}
|
||||
@MainActor func testAutomaticVenueQueueAdvancesAndRecordsSinger() async throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at:root) }
|
||||
let model = AppModel(storageURL:root); defer { model.player.stop() }
|
||||
_ = try model.createEntity(.venue,name:"Test Hall")
|
||||
_ = try model.createEntity(.singer,name:"Alex")
|
||||
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
|
||||
model.importFiles([fixtures.appendingPathComponent("Demo.zip")])
|
||||
let song = try XCTUnwrap(model.songs.first)
|
||||
model.enqueue(song.id); model.enqueue(song.id); model.playQueueNext()
|
||||
XCTAssertEqual(model.queue.count,1); XCTAssertEqual(model.history.count,1)
|
||||
model.player.seek(model.player.duration-0.1)
|
||||
for _ in 0..<25 {
|
||||
if model.queue.isEmpty { break }
|
||||
try await Task.sleep(nanoseconds:100_000_000)
|
||||
}
|
||||
XCTAssertNil(model.error); XCTAssertTrue(model.queue.isEmpty)
|
||||
XCTAssertEqual(model.history.count,2); XCTAssertEqual(model.history.first?.singer,"Alex")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user