support multiple instances with different layouts

if specified layout for nth instance is different than 1st, the player data is shared instead of the waybar output.
only share output when args are identical; use fixed length socket
2021-05-17 16:10:14 +01:00 · 2021-05-17 13:44:24 +01:00
2 changed files with 305 additions and 76 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +1,2 @@
 ./main
-./waybar-mpris
+waybar-mpris
--- a/main.go
+++ b/main.go
@ -7,6 +7,7 @@ import (
 	"net"
 	"os"
 	"os/signal"
+	"strconv"
 	"strings"
 	"time"

@ -18,10 +19,11 @@ import (

 // Various paths and values to use elsewhere.
 const (
-	SOCK    = "/tmp/waybar-mpris.sock"
-	LOGFILE = "/tmp/waybar-mpris.log"
-	OUTFILE = "/tmp/waybar-mpris.out"
-	POLL    = 1
+	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.
@ -32,16 +34,122 @@ var (
 	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
-	WRITER      io.Writer = os.Stdout
+	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 *mpris2.Player) string {
+func playerJSON(p *player) string {
 	symbol := PLAY
 	out := "{\"class\": \""
 	if p.Playing {
@ -52,9 +160,14 @@ func playerJSON(p *mpris2.Player) string {
 	}
 	var pos string
 	if SHOW_POS {
-		pos = p.StringPosition()
-		if pos != "" {
-			pos = "(" + pos + ")"
+		if !p.Duplicate {
+			pos = p.StringPosition()
+			if pos != "" {
+				pos = "(" + pos + ")"
+			}
+		} else {
+			pos = "(" + secondsToString(int(p.Position/1000000)) + "/" + secondsToString(p.Length) + ")"
+
 		}
 	}
 	var items []string
@ -124,7 +237,7 @@ type players struct {

 func (pl *players) JSON() string {
 	if len(pl.mpris2.List) != 0 {
-		return playerJSON(pl.mpris2.List[pl.mpris2.Current])
+		return playerJSON(&player{pl.mpris2.List[pl.mpris2.Current], false})
 	}
 	return "{}"
 }
@ -140,7 +253,8 @@ func execCommand(cmd string) {
 	if err != nil {
 		log.Fatalln("Couldn't dial:", err)
 	}
-	_, err = conn.Write([]byte(cmd))
+	shortCmd := stringToCmd(cmd)
+	_, err = conn.Write([]byte(shortCmd))
 	if err != nil {
 		log.Fatalln("Couldn't send command")
 	}
@ -158,69 +272,145 @@ func execCommand(cmd string) {
 	os.Exit(0)
 }

-func duplicateOutput(conn net.Conn) {
+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.")
-	// Tell other instance to share output in OUTFILE
-	_, err := conn.Write([]byte("share"))
+
+	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
 	}
-	if resp := string(buf[0:nr]); resp == "success" {
-		// 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)
+	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("Failed to open \"%s\": %v", OUTFILE, err)
+			log.Fatalf("Couldn't send command: %v", err)
 		}
-		watcher, err := fsnotify.NewWatcher()
+		buf = make([]byte, 2)
+		nr, err := conn.Read(buf)
 		if err != nil {
-			log.Fatalf("Failed to start watcher: %v", err)
+			log.Fatalf("Couldn't read response: %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
+		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)
+					}
 				}
-				if event.Op&fsnotify.Write == fsnotify.Write {
-					l, err := io.ReadAll(f)
-					if err != nil {
-						log.Printf("Failed to read file: %v", err)
-						return
+			}
+		}
+	} 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
 					}
-					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)
+					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)
 					}
-					f.Seek(0, 0)
 				}
 			}
 		}
 	}
-
+	return nil
 }

 func listenForCommands(players *players) {
@ -246,7 +436,7 @@ func listenForCommands(players *players) {
 			log.Println("Couldn't accept:", err)
 			continue
 		}
-		buf := make([]byte, 512)
+		buf := make([]byte, 2)
 		nr, err := con.Read(buf)
 		if err != nil {
 			log.Println("Couldn't read:", err)
@ -254,7 +444,7 @@ func listenForCommands(players *players) {
 		}
 		command := string(buf[0:nr])
 		switch command {
-		case "player-next":
+		case cPlayerNext:
 			length := len(players.mpris2.List)
 			if length != 1 {
 				if players.mpris2.Current < uint(length-1) {
@ -264,7 +454,7 @@ func listenForCommands(players *players) {
 				}
 				players.mpris2.Refresh()
 			}
-		case "player-prev":
+		case cPlayerPrev:
 			length := len(players.mpris2.List)
 			if length != 1 {
 				if players.mpris2.Current != 0 {
@ -274,32 +464,75 @@ func listenForCommands(players *players) {
 				}
 				players.mpris2.Refresh()
 			}
-		case "next":
+		case cNext:
 			players.Next()
-		case "prev":
+		case cPrev:
 			players.Prev()
-		case "toggle":
+		case cToggle:
 			players.Toggle()
-		case "list":
+		case cList:
 			con.Write([]byte(players.mpris2.String()))
-		case "share":
+		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(SHAREWRITER, DATAWRITER, os.Stdout)
+				} else {
+					WRITER = io.MultiWriter(DATAWRITER, os.Stdout)
+				}
+				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)
 				}
-				var out io.Writer = emptyEveryWrite{file: f}
-				WRITER = io.MultiWriter(os.Stdout, out)
+				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, "success")
+			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})
+	return w.emptyEveryWrite.Write([]byte(line))
+}
+
 type emptyEveryWrite struct {
 	file *os.File
 }
@ -356,13 +589,9 @@ func main() {
 				ignoreChoice = true
 				// os.Remove(SOCK)
 			}
-		} else if conn, err := net.Dial("unix", SOCK); err == nil {
 			// When waybar-mpris is already running, we attach to its output instead of launching a whole new instance.
-			duplicateOutput(conn)
-		} else {
-			if err != nil {
-				os.Stdout.WriteString("Couldn't dial socket, deleting instead: " + err.Error())
-			}
+		} else if err := duplicateOutput(); err != nil {
+			os.Stdout.WriteString("Couldn't dial socket, deleting instead: " + err.Error())
 			os.Remove(SOCK)
 			os.Remove(OUTFILE)
 		}
Author	SHA1	Message	Date
Harvey Tindall	49b3212c48	support multiple instances with different layouts All checks were successful continuous-integration/drone/push Build is passing Details if specified layout for nth instance is different than 1st, the player data is shared instead of the waybar output.	2021-05-17 16:10:14 +01:00
Harvey Tindall	ea4f47a1b1	only share output when args are identical; use fixed length socket commands fixed length commands were originally a guess for an issue I was having, but it's cleaner this way anyway.	2021-05-17 13:44:24 +01:00