package main import ( "encoding/json" "fmt" "io" "log" "net" "os" "os/signal" "strconv" "strings" "time" "github.com/fsnotify/fsnotify" "github.com/godbus/dbus/v5" mpris2 "github.com/hrfee/mpris2client" flag "github.com/spf13/pflag" ) // Various paths and values to use elsewhere. const ( SOCK = "/tmp/waybar-mpris.sock" LOGFILE = "/tmp/waybar-mpris.log" OUTFILE = "/tmp/waybar-mpris.out" // Used for sharing waybar output when args are the same. DATAFILE = "/tmp/waybar-mpris.data.out" // Used for sharing "\n"-separated player data between instances when args are different. POLL = 1 ) // Mostly default values for flag options. var ( playIcon = "▶" pauseIcon = "" textFormat = "%i %a - %t (%p/%d)" tooltipFormat = "%t by %a from %A\n(%P)" autofocus = false // Available commands that can be sent to running instances. commands = []string{"player-next", "player-prev", "next", "prev", "toggle", "list"} showPos = false interpolate = false replace = false isSharing = false isDataSharing = false maxTitleLen = 70 writer io.Writer = os.Stdout shareWriter, dataWriter io.Writer ) // Format tokens `%` const ( tokIcon = 'i' tokArtist = 'a' tokAlbum = 'A' tokTitle = 't' tokPosition = 'p' tokLength = 'd' tokPlayer = 'P' tokPercent = '%' ) const ( cPlayerNext = "pn" cPlayerPrev = "pp" cNext = "mn" cPrev = "mp" cToggle = "mt" cList = "ls" cShare = "sh" cPreShare = "ps" cDataShare = "ds" rSuccess = "sc" rInvalidCommand = "iv" rFailed = "fa" ) func stringToCmd(str string) string { switch str { case "player-next": return cPlayerNext case "player-prev": return cPlayerPrev case "next": return cNext case "prev": return cPrev case "toggle": return cToggle case "list": return cList case "share": return cShare case "data-share": return cDataShare case "pre-share": return cPreShare } return "" } // length-µS\nposition-µS\nplaying (0 or 1)\nartist\nalbum\ntitle\nplayer\n func fromData(p *player, cmd string) { p.Duplicate = true values := make([]string, 7) prev := 0 current := 0 for i := range cmd { if current == len(values) { break } if cmd[i] == '\n' { values[current] = cmd[prev:i] prev = i + 1 current++ } } l, err := strconv.ParseInt(values[0], 10, 64) if err != nil { l = -1 } p.Length = int(l) / 1000000 pos, err := strconv.ParseInt(values[1], 10, 64) if err != nil { pos = -1 } p.Position = pos if values[2] == "1" { p.Playing = true } else { p.Playing = false } p.Artist = values[3] p.Album = values[4] p.Title = values[5] p.Name = values[6] } func toData(p *player) (cmd string) { cmd += strconv.FormatInt(int64(p.Length*1000000), 10) + "\n" cmd += strconv.FormatInt(p.Position, 10) + "\n" if p.Playing { cmd += "1" } else { cmd += "0" } cmd += "\n" cmd += p.Artist + "\n" cmd += p.Album + "\n" cmd += p.Title + "\n" cmd += p.Name + "\n" return } type player struct { *mpris2.Player Duplicate bool } // This represents the output in JSON format that waybar is expecting type waybarData struct { Class string `json:"class"` Text string `json:"text"` Tooltip string `json:"tooltip"` } func secondsToString(seconds int) string { minutes := int(seconds / 60) seconds -= int(minutes * 60) return fmt.Sprintf("%02d:%02d", minutes, seconds) } func formatOutput(p *player, icon string, fstr string) string { var buf []byte for i := 0; i < len(fstr); i++ { if fstr[i] == '%' { i++ if i >= len(fstr) { break } switch fstr[i] { case tokIcon: buf = append(buf, []byte(icon)...) case tokArtist: buf = append(buf, []byte(p.Artist)...) case tokAlbum: buf = append(buf, []byte(p.Album)...) case tokTitle: title := p.Title if maxTitleLen > 0 && len(title) > maxTitleLen { title = title[:maxTitleLen-3] + "..." } buf = append(buf, []byte(title)...) case tokPosition: position := secondsToString(int(p.Position / 1000000)) buf = append(buf, []byte(position)...) case tokLength: length := secondsToString(p.Length) buf = append(buf, []byte(length)...) case tokPlayer: buf = append(buf, []byte(p.Name)...) default: buf = append(buf, fstr[i]) } } else { buf = append(buf, fstr[i]) } } out := strings.ReplaceAll(string(buf), `"`, `\"`) out = strings.ReplaceAll(out, "&", "&") return out } // Returns JSON for waybar to consume. func playerJSON(p *player) string { data := waybarData{} icon := playIcon if p.Playing { icon = pauseIcon data.Class = "playing" } else { data.Class = "paused" } data.Text = formatOutput(p, icon, textFormat) data.Tooltip = formatOutput(p, icon, tooltipFormat) out, err := json.Marshal(data) if err != nil { return "{}" } return string(out) } type players struct { mpris2 *mpris2.Mpris2 } func (pl *players) JSON() string { if len(pl.mpris2.List) != 0 { return playerJSON(&player{pl.mpris2.List[pl.mpris2.Current], false}) } return "{}" } func (pl *players) Next() { pl.mpris2.List[pl.mpris2.Current].Next() } func (pl *players) Prev() { pl.mpris2.List[pl.mpris2.Current].Previous() } func (pl *players) Toggle() { pl.mpris2.List[pl.mpris2.Current].Toggle() } func execCommand(cmd string) { conn, err := net.Dial("unix", SOCK) if err != nil { log.Fatalln("Couldn't dial:", err) } shortCmd := stringToCmd(cmd) _, err = conn.Write([]byte(shortCmd)) if err != nil { log.Fatalln("Couldn't send command") } fmt.Println("Sent.") if cmd == "list" { buf := make([]byte, 512) nr, err := conn.Read(buf) if err != nil { log.Fatalln("Couldn't read response.") } response := string(buf[0:nr]) fmt.Println("Response:") fmt.Printf(response) } os.Exit(0) } func duplicateOutput() error { // Print to stderr to avoid errors from waybar os.Stderr.WriteString("waybar-mpris is already running. This instance will clone its output.") conn, err := net.Dial("unix", SOCK) if err != nil { return err } _, err = conn.Write([]byte(cPreShare)) if err != nil { log.Fatalf("Couldn't send command: %v", err) return err } buf := make([]byte, 512) nr, err := conn.Read(buf) if err != nil { log.Fatalf("Couldn't read response: %v", err) return err } argString := "" for _, arg := range os.Args { argString += arg + "|" } conn.Close() conn, err = net.Dial("unix", SOCK) if err != nil { return err } if string(buf[0:nr]) == argString { // Tell other instance to share output in OUTFILE _, err := conn.Write([]byte(cShare)) if err != nil { log.Fatalf("Couldn't send command: %v", err) } buf = make([]byte, 2) nr, err := conn.Read(buf) if err != nil { log.Fatalf("Couldn't read response: %v", err) } if resp := string(buf[0:nr]); resp == rSuccess { // t, err := tail.TailFile(OUTFILE, tail.Config{ // Follow: true, // MustExist: true, // Logger: tail.DiscardingLogger, // }) // if err == nil { // for line := range t.Lines { // fmt.Println(line.Text) // } // } f, err := os.Open(OUTFILE) if err != nil { log.Fatalf("Failed to open \"%s\": %v", OUTFILE, err) } watcher, err := fsnotify.NewWatcher() if err != nil { log.Fatalf("Failed to start watcher: %v", err) } defer watcher.Close() err = watcher.Add(OUTFILE) if err != nil { log.Fatalf("Failed to watch file: %v", err) } for { select { case event, ok := <-watcher.Events: if !ok { log.Printf("Watcher failed: %v", err) return err } if event.Op&fsnotify.Write == fsnotify.Write { l, err := io.ReadAll(f) if err != nil { log.Printf("Failed to read file: %v", err) return err } str := string(l) // Trim extra newline is necessary if str[len(str)-2:] == "\n\n" { fmt.Print(str[:len(str)-1]) } else { fmt.Print(str) } f.Seek(0, 0) } } } } } else { _, err := conn.Write([]byte(cDataShare)) if err != nil { log.Fatalf("Couldn't send command: %v", err) } buf = make([]byte, 2) nr, err := conn.Read(buf) if err != nil { log.Fatalf("Couldn't read response: %v", err) } if resp := string(buf[0:nr]); resp == rSuccess { f, err := os.Open(DATAFILE) if err != nil { log.Fatalf("Failed to open \"%s\": %v", DATAFILE, err) } watcher, err := fsnotify.NewWatcher() if err != nil { log.Fatalf("Failed to start watcher: %v", err) } defer watcher.Close() err = watcher.Add(DATAFILE) if err != nil { log.Fatalf("Failed to watch file: %v", err) } p := &player{ &mpris2.Player{}, true, } for { select { case event, ok := <-watcher.Events: if !ok { log.Printf("Watcher failed: %v", err) return err } if event.Op&fsnotify.Write == fsnotify.Write { l, err := io.ReadAll(f) if err != nil { log.Printf("Failed to read file: %v", err) return err } str := string(l) fromData(p, str) fmt.Fprintln(writer, playerJSON(p)) f.Seek(0, 0) } } } } } return nil } func listenForCommands(players *players) { listener, err := net.Listen("unix", SOCK) c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) go func() { <-c os.Remove(OUTFILE) os.Remove(SOCK) os.Exit(1) }() if err != nil { log.Fatalf("Couldn't establish socket connection at %s (error %s)\n", SOCK, err) } defer func() { listener.Close() os.Remove(SOCK) }() for { con, err := listener.Accept() if err != nil { log.Println("Couldn't accept:", err) continue } buf := make([]byte, 2) nr, err := con.Read(buf) if err != nil { log.Println("Couldn't read:", err) continue } command := string(buf[0:nr]) switch command { case cPlayerNext: length := len(players.mpris2.List) if length != 1 { if players.mpris2.Current < uint(length-1) { players.mpris2.Current++ } else { players.mpris2.Current = 0 } players.mpris2.Refresh() } case cPlayerPrev: length := len(players.mpris2.List) if length != 1 { if players.mpris2.Current != 0 { players.mpris2.Current-- } else { players.mpris2.Current = uint(length - 1) } players.mpris2.Refresh() } case cNext: players.Next() case cPrev: players.Prev() case cToggle: players.Toggle() case cList: con.Write([]byte(players.mpris2.String())) case cDataShare: if !isDataSharing { f, err := os.OpenFile(DATAFILE, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666) defer f.Close() if err != nil { fmt.Fprintf(con, "Failed: %v", err) } dataWriter = dataWrite{ emptyEveryWrite{file: f}, players, } if isSharing { writer = io.MultiWriter(os.Stdout, shareWriter, dataWriter) } else { writer = io.MultiWriter(os.Stdout, dataWriter) } isDataSharing = true } fmt.Fprint(con, rSuccess) case cShare: if !isSharing { f, err := os.OpenFile(OUTFILE, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666) defer f.Close() if err != nil { fmt.Fprintf(con, "Failed: %v", err) } shareWriter = emptyEveryWrite{file: f} if isDataSharing { writer = io.MultiWriter(shareWriter, dataWriter, os.Stdout) } else { writer = io.MultiWriter(shareWriter, os.Stdout) } isSharing = true } fmt.Fprint(con, rSuccess) /* Prior to sharing, the first instance sends its os.Args. If the second instances args are different, the first sends the raw data (artist, album, etc.) If they are the same, the first instance just sends its output and the second prints it. */ case cPreShare: out := "" for _, arg := range os.Args { out += arg + "|" } con.Write([]byte(out)) default: fmt.Println("Invalid command") } con.Close() } } type dataWrite struct { emptyEveryWrite Players *players } func (w dataWrite) Write(p []byte) (n int, err error) { line := toData(&player{w.Players.mpris2.List[w.Players.mpris2.Current], true}) _, err = w.emptyEveryWrite.Write([]byte(line)) n = len(p) return } type emptyEveryWrite struct { file *os.File } func (w emptyEveryWrite) Write(p []byte) (n int, err error) { n = len(p) // Set new size in case previous data was longer and would leave garbage at the end of the file. err = w.file.Truncate(int64(n)) if err != nil { return 0, err } offset, err := w.file.Seek(0, 0) if err != nil { return 0, err } _, err = w.file.WriteAt(p, offset) return } func main() { logfile, err := os.OpenFile(LOGFILE, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666) if err != nil { log.Fatalf("Couldn't open %s for writing: %s", LOGFILE, err) } mw := io.MultiWriter(logfile, os.Stdout) log.SetOutput(mw) flag.StringVar(&playIcon, "play", playIcon, "Play symbol/text to use.") flag.StringVar(&pauseIcon, "pause", pauseIcon, "Pause symbol/text to use.") flag.StringVar(&textFormat, "text-format", textFormat, "Format of the waybar module text.") flag.StringVar(&tooltipFormat, "tooltip-format", tooltipFormat, "Format of the waybar module tooltip.") flag.BoolVar(&autofocus, "autofocus", autofocus, "Auto switch to currently playing music players.") flag.BoolVar(&interpolate, "interpolate", interpolate, "Interpolate track position (helpful for players that don't update regularly, e.g mpDris2)") flag.BoolVar(&replace, "replace", replace, "Replace existing waybar-mpris if found. When false, new instance will clone the original instances output.") flag.IntVar(&maxTitleLen, "max-title", maxTitleLen, "Maximum length of title. If the title's longer N-3 characters will be printed and ... will be printed at the end.") var command string flag.StringVar(&command, "send", "", "send command to already runnning waybar-mpris instance. (options: "+strings.Join(commands, "/")+")") flag.Parse() os.Stderr = logfile if command != "" { execCommand(command) } // fmt.Println("New array", players) // Start command listener if _, err := os.Stat(SOCK); err == nil { if replace { fmt.Printf("Socket %s already exists, this could mean waybar-mpris is already running.\nStarting this instance will overwrite the file, possibly stopping other instances from accepting commands.\n", SOCK) var input string ignoreChoice := false fmt.Printf("Continue? [y/n]: ") go func() { fmt.Scanln(&input) if strings.Contains(input, "y") && !ignoreChoice { os.Remove(SOCK) } }() time.Sleep(5 * time.Second) if input == "" { fmt.Printf("\nRemoving due to lack of input.\n") ignoreChoice = true // os.Remove(SOCK) } // When waybar-mpris is already running, we attach to its output instead of launching a whole new instance. } else if err := duplicateOutput(); err != nil { os.Stderr.WriteString("Couldn't dial socket, deleting instead: " + err.Error()) os.Remove(SOCK) os.Remove(OUTFILE) } } conn, err := dbus.SessionBus() if err != nil { log.Fatalln("Error connecting to DBus:", err) } players := &players{ mpris2: mpris2.NewMpris2(conn, interpolate, POLL, autofocus), } players.mpris2.Reload() players.mpris2.Sort() lastLine := "" go listenForCommands(players) go players.mpris2.Listen() if showPos { go func() { for { time.Sleep(POLL * time.Second) if len(players.mpris2.List) != 0 { if players.mpris2.List[players.mpris2.Current].Playing { go fmt.Fprintln(writer, players.JSON()) } } } }() } fmt.Fprintln(writer, players.JSON()) for v := range players.mpris2.Messages { if v.Name == "refresh" { if autofocus { players.mpris2.Sort() } if l := players.JSON(); l != lastLine { lastLine = l fmt.Fprintln(writer, l) } } } players.mpris2.Refresh() }