MPRIS2 waybar component
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

640 lines
15 KiB

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()
}