package main import ( "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 ( PLAY = "▶" PAUSE = "" SEP = " - " ORDER = "SYMBOL:ARTIST:ALBUM:TITLE:POSITION" AUTOFOCUS = false // Available commands that can be sent to running instances. COMMANDS = []string{"player-next", "player-prev", "next", "prev", "toggle", "list"} SHOW_POS = false INTERPOLATE = false REPLACE = false isSharing = false isDataSharing = false WRITER io.Writer = os.Stdout SHAREWRITER, DATAWRITER io.Writer ) 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 } func secondsToString(seconds int) string { minutes := int(seconds / 60) seconds -= int(minutes * 60) return fmt.Sprintf("%02d:%02d", minutes, seconds) } // JSON returns json for waybar to consume. func playerJSON(p *player) string { symbol := PLAY out := "{\"class\": \"" if p.Playing { symbol = PAUSE out += "playing" } else { out += "paused" } var pos string if SHOW_POS { if !p.Duplicate { pos = p.StringPosition() if pos != "" { pos = "(" + pos + ")" } } else { pos = "(" + secondsToString(int(p.Position/1000000)) + "/" + secondsToString(p.Length) + ")" } } var items []string order := strings.Split(ORDER, ":") for _, v := range order { switch v { case "SYMBOL": items = append(items, symbol) case "ARTIST": if p.Artist != "" { items = append(items, p.Artist) } case "ALBUM": if p.Album != "" { items = append(items, p.Album) } case "TITLE": if p.Title != "" { items = append(items, p.Title) } case "POSITION": if pos != "" && SHOW_POS { items = append(items, pos) } case "PLAYER": if p.Name != "" { items = append(items, p.Name) } } } if len(items) == 0 { return "{}" } text := "" for i, v := range items { right := "" if (v == symbol || v == pos) && i != len(items)-1 { right = " " } else if i != len(items)-1 && items[i+1] != symbol && items[i+1] != pos { right = SEP } else { right = " " } text += v + right } out += "\",\"text\":\"" + text + "\"," out += "\"tooltip\":\"" + strings.ReplaceAll(p.Title, "&", "&") + "\\n" if p.Artist != "" { out += "by " + strings.ReplaceAll(p.Artist, "&", "&") + "\\n" } if p.Album != "" { out += "from " + strings.ReplaceAll(p.Album, "&", "&") + "\\n" } out += "(" + p.Name + ")\"}" return out // return fmt.Sprintf("{\"class\":\"%s\",\"text\":\"%s\",\"tooltip\":\"%s\"}", data["class"], data["text"], data["tooltip"]) // 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) { offset, err := w.file.Seek(0, 0) if err != nil { return 0, err } _, err = w.file.WriteAt(p, offset) n = len(p) 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(&PLAY, "play", PLAY, "Play symbol/text to use.") flag.StringVar(&PAUSE, "pause", PAUSE, "Pause symbol/text to use.") flag.StringVar(&SEP, "separator", SEP, "Separator string to use between artist, album, and title.") flag.StringVar(&ORDER, "order", ORDER, "Element order. An extra \"PLAYER\" element is also available.") flag.BoolVar(&AUTOFOCUS, "autofocus", AUTOFOCUS, "Auto switch to currently playing music players.") flag.BoolVar(&SHOW_POS, "position", SHOW_POS, "Show current position between brackets, e.g (04:50/05:00)") 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.") 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.Stdout.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 SHOW_POS { 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() }