Filthy aphid

player/player.go

@@ -4,6 +4,7 @@ import (
 	"os"
 	"os/exec"
 	"sync"
+	"time"
 )
 
 // Player handles alarm sound playback by shelling out to system audio tools.
@@ -11,72 +12,129 @@ type Player struct {
 	mu      sync.Mutex
 	cmd     *exec.Cmd
 	playing bool
+	stopCh  chan struct{}
 }
 
 func New() *Player {
 	return &Player{}
 }
 
-// Play starts playing a sound file. If path is "default", it uses a system beep.
-func (p *Player) Play(path string) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	p.stop()
-
-	if path == "default" || path == "" {
-		// Try common system sounds, fall back to terminal bell
-		candidates := []string{
-			"/usr/share/sounds/freedesktop/stereo/alarm-clock-elapsed.oga",
-			"/usr/share/sounds/gnome/default/alerts/bark.ogg",
-			"/usr/share/sounds/sound-icons/trumpet-12.wav",
+// resolveSound finds the actual file path for a sound. Returns "" if no file found.
+func resolveSound(path string) string {
+	if path != "default" && path != "" {
+		if _, err := os.Stat(path); err == nil {
+			return path
 		}
-		for _, c := range candidates {
-			if _, err := os.Stat(c); err == nil {
-				path = c
-				break
-			}
-		}
-		if path == "default" || path == "" {
-			// No sound files found — use terminal bell in a loop
-			go func() {
-				for i := 0; i < 10; i++ {
-					os.Stdout.WriteString("\a")
-				}
-			}()
-			return
+		return ""
+	}
+	candidates := []string{
+		"/usr/share/sounds/freedesktop/stereo/alarm-clock-elapsed.oga",
+		"/usr/share/sounds/gnome/default/alerts/bark.ogg",
+		"/usr/share/sounds/sound-icons/trumpet-12.wav",
+	}
+	for _, c := range candidates {
+		if _, err := os.Stat(c); err == nil {
+			return c
 		}
 	}
+	return ""
+}
 
-	// Try players in order of preference
+// findPlayer returns the name and arg builder for the first available audio player.
+func findPlayer() (string, func(string) []string) {
 	players := []struct {
 		name string
 		args func(string) []string
 	}{
 		{"paplay", func(f string) []string { return []string{f} }},
 		{"aplay", func(f string) []string { return []string{f} }},
-		{"mpv", func(f string) []string { return []string{"--no-video", "--loop=inf", f} }},
-		{"ffplay", func(f string) []string { return []string{"-nodisp", "-autoexit", "-loop", "0", f} }},
+		{"mpv", func(f string) []string { return []string{"--no-video", "--no-terminal", f} }},
+		{"ffplay", func(f string) []string { return []string{"-nodisp", "-autoexit", f} }},
 	}
-
 	for _, pl := range players {
 		if _, err := exec.LookPath(pl.name); err == nil {
-			p.cmd = exec.Command(pl.name, pl.args(path)...)
-			p.cmd.Stdout = nil
-			p.cmd.Stderr = nil
-			p.playing = true
-			go func() {
-				_ = p.cmd.Run()
-				p.mu.Lock()
-				p.playing = false
-				p.mu.Unlock()
-			}()
-			return
+			return pl.name, pl.args
 		}
 	}
+	return "", nil
+}
 
-	// Absolute fallback: terminal bell
-	os.Stdout.WriteString("\a")
+// PlayLoop starts playing a sound file in a loop until Stop() is called.
+func (p *Player) PlayLoop(path string) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	p.stop()
+
+	resolved := resolveSound(path)
+	if resolved == "" {
+		// No sound file — bell loop
+		p.stopCh = make(chan struct{})
+		p.playing = true
+		go func() {
+			ticker := time.NewTicker(2 * time.Second)
+			defer ticker.Stop()
+			os.Stdout.WriteString("\a")
+			for {
+				select {
+				case <-p.stopCh:
+					return
+				case <-ticker.C:
+					os.Stdout.WriteString("\a")
+				}
+			}
+		}()
+		return
+	}
+
+	name, argsFn := findPlayer()
+	if name == "" {
+		os.Stdout.WriteString("\a")
+		return
+	}
+
+	p.stopCh = make(chan struct{})
+	p.playing = true
+
+	go func() {
+		for {
+			select {
+			case <-p.stopCh:
+				return
+			default:
+			}
+
+			cmd := exec.Command(name, argsFn(resolved)...)
+			cmd.Stdout = nil
+			cmd.Stderr = nil
+
+			p.mu.Lock()
+			p.cmd = cmd
+			p.mu.Unlock()
+
+			err := cmd.Run()
+
+			p.mu.Lock()
+			p.cmd = nil
+			p.mu.Unlock()
+
+			if err != nil {
+				// Check if we were told to stop
+				select {
+				case <-p.stopCh:
+					return
+				default:
+				}
+			}
+
+			// Brief pause between loops to avoid hammering
+			select {
+			case <-p.stopCh:
+				return
+			case <-time.After(300 * time.Millisecond):
+			}
+		}
+	}()
 }
 
 // Stop stops any currently playing sound.
@@ -87,12 +145,16 @@ func (p *Player) Stop() {
 }
 
 func (p *Player) stop() {
-	if p.cmd != nil && p.cmd.Process != nil && p.playing {
+	if p.stopCh != nil {
+		close(p.stopCh)
+		p.stopCh = nil
+	}
+	if p.cmd != nil && p.cmd.Process != nil {
 		_ = p.cmd.Process.Kill()
 		_ = p.cmd.Wait()
-		p.playing = false
 		p.cmd = nil
 	}
+	p.playing = false
 }
 
 func (p *Player) IsPlaying() bool {