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.

.gitignore

@@ -1,2 +1,2 @@
 ./main
-./waybar-mpris
+waybar-mpris

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"
+	SOCK     = "/tmp/waybar-mpris.sock"
-	LOGFILE = "/tmp/waybar-mpris.log"
+	LOGFILE  = "/tmp/waybar-mpris.log"
-	OUTFILE = "/tmp/waybar-mpris.out"
+	OUTFILE  = "/tmp/waybar-mpris.out"      // Used for sharing waybar output when args are the same.
-	POLL    = 1
+	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"}
+	COMMANDS                          = []string{"player-next", "player-prev", "next", "prev", "toggle", "list"}
-	SHOW_POS              = false
+	SHOW_POS                          = false
-	INTERPOLATE           = false
+	INTERPOLATE                       = false
-	REPLACE               = false
+	REPLACE                           = false
-	isSharing             = false
+	isSharing                         = false
-	WRITER      io.Writer = os.Stdout
+	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 !p.Duplicate {
-		if pos != "" {
+			pos = p.StringPosition()
-			pos = "(" + pos + ")"
+			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" {
+	argString := ""
-		// t, err := tail.TailFile(OUTFILE, tail.Config{
+	for _, arg := range os.Args {
-		// 	Follow:    true,
+		argString += arg + "|"
-		// 	MustExist: true,
+	}
-		// 	Logger:    tail.DiscardingLogger,
+	conn.Close()
-		// })
+	conn, err = net.Dial("unix", SOCK)
-		// if err == nil {
+	if err != nil {
-		// 	for line := range t.Lines {
+		return err
-		// 		fmt.Println(line.Text)
+	}
-		// 	}
+	if string(buf[0:nr]) == argString {
-		// }
+		// Tell other instance to share output in OUTFILE
-		f, err := os.Open(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()
+		if resp := string(buf[0:nr]); resp == rSuccess {
-		err = watcher.Add(OUTFILE)
+			// t, err := tail.TailFile(OUTFILE, tail.Config{
-		if err != nil {
+			// 	Follow:    true,
-			log.Fatalf("Failed to watch file: %v", err)
+			// 	MustExist: true,
-		}
+			// 	Logger:    tail.DiscardingLogger,
-		for {
+			// })
-			select {
+			// if err == nil {
-			case event, ok := <-watcher.Events:
+			// 	for line := range t.Lines {
-				if !ok {
+			// 		fmt.Println(line.Text)
-					log.Printf("Watcher failed: %v", err)
+			// 	}
-					return
+			// }
+			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 {
+	} else {
-						log.Printf("Failed to read file: %v", err)
+		_, err := conn.Write([]byte(cDataShare))
-						return
+		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)
+					if event.Op&fsnotify.Write == fsnotify.Write {
-					// Trim extra newline is necessary
+						l, err := io.ReadAll(f)
-					if str[len(str)-2:] == "\n\n" {
+						if err != nil {
-						fmt.Print(str[:len(str)-1])
+							log.Printf("Failed to read file: %v", err)
-					} else {
+							return err
-						fmt.Print(str)
+						}
+						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}
+				SHAREWRITER = emptyEveryWrite{file: f}
-				WRITER = io.MultiWriter(os.Stdout, out)
+				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 := duplicateOutput(); err != nil {
-		} else {
+			os.Stdout.WriteString("Couldn't dial socket, deleting instead: " + err.Error())
-			if err != nil {
-				os.Stdout.WriteString("Couldn't dial socket, deleting instead: " + err.Error())
-			}
 			os.Remove(SOCK)
 			os.Remove(OUTFILE)
 		}