escape double quotes

Fixes bug where recipient instance would have a bit of the previous
track data on the end of the output if the previous track data was
longer, which effectively froze the output on waybar as it was no longer
valid JSON.

.drone.yml

@@ -0,0 +1,36 @@
+name: waybar-mpris
+kind: pipeline
+type: docker
+
+steps:
+    - name: build
+      image: golang:latest
+      volumes:
+        - name: ssh_key
+          path: /id_rsa
+      commands:
+        - apt update -y
+        - apt install -y python3-pip curl
+        - go mod download
+        - curl -sL https://git.io/goreleaser > goreleaser.sh
+        - chmod +x goreleaser.sh
+        - ./version.sh ./goreleaser.sh --snapshot --skip-publish --rm-dist
+        - wget https://builds.hrfee.pw/upload.py
+        - pip3 install requests
+        - bash -c 'python3 upload.py https://builds2.hrfee.pw hrfee waybar-mpris --upload ./dist/*.tar.gz ./dist/*.rpm'
+        - bash -c 'sftp -P 2022 -i /id_rsa -o StrictHostKeyChecking=no root@161.97.102.153:/repo/incoming <<< $"put dist/*.deb"'
+        - bash -c 'ssh -i /id_rsa root@161.97.102.153 -p 2022 "repo-process-deb trusty-unstable"'
+      environment:
+          BUILDRONE_KEY:
+              from_secret: BUILDRONE_KEY
+
+volumes:
+    - name: ssh_key
+      host:
+          path: /root/.ssh/id_rsa_packaging
+trigger:
+    branch:
+        - main
+    event:
+        exclude:
+            - pull_request

.gitignore

@@ -1 +1,3 @@
 ./main
+waybar-mpris
+dist/*

.goreleaser.yml

@@ -0,0 +1,55 @@
+project_name: waybar-mpris
+release:
+    gitea:
+        owner: hrfee
+        name: waybar-mpris
+    name_template: "v{{.Version}}"
+before:
+  hooks:
+    - go mod download
+builds:
+    - id: main
+      dir: ./
+      env:
+        - CGO_ENABLED=0
+      goos:
+        - linux
+      goarch:
+        - amd64
+        - arm
+        - arm64
+archives:
+  - id: main
+    builds:
+      - main
+    replacements:
+        linux: Linux
+        amd64: x86_64
+checksum:
+    name_template: 'checksums.txt'
+snapshot:
+    name_template: "0.0.0-{{.Env.NFPM_EPOCH}}"
+changelog:
+    sort: asc
+    filters:
+        exclude:
+            - '^docs:'
+            - '^test:'
+nfpms:
+  - id: main
+    file_name_template: '{{ .ProjectName }}-git-{{ .ShortCommit }}_{{ .Arch }}'
+    package_name: waybar-mpris
+    homepage: https://git.hrfee.pw/hrfee/waybar-mpris
+    description: MPRIS2 waybar component
+    maintainer: Harvey Tindall <hrfee@hrfee.dev>
+    license: MIT
+    vendor: hrfee.dev
+    version_metadata: git
+    builds:
+      - main
+    contents:
+      - src: ./LICENSE
+        dst: /usr/share/licenses/waybar-mpris
+    formats:
+      - deb
+      - rpm

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Harvey Tindall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -3,11 +3,15 @@
     <img src="images/cropped.gif" style="width: 100%;" alt="bar gif"></img>
 </p>
 
+##### Downloads:
+##### [binary](https://builds2.hrfee.pw/view/hrfee/waybar-mpris) | [aur](https://aur.archlinux.org/packages/waybar-mpris-git/)
+
 a waybar component/utility for displaying and controlling MPRIS2 compliant media players individually, inspired by [waybar-media](https://github.com/yurihs/waybar-media). 
 
 MPRIS2 is widely supported, so this component should work with:
 * Chrome/Chromium
-* Other browsers (with kde plasma integration installed)
+* Firefox (Limited support with `media.hardwaremediakeys.enabled = true` in about:config)
+* Other browsers (using KDE Plasma Integration)
 * VLC
 * Spotify
 * Noson
@@ -15,10 +19,23 @@ MPRIS2 is widely supported, so this component should work with:
 * Most other music/media players
 
 ## Install
-`go get git.hrfee.pw/hrfee/waybar-mpris` will install the program, as well as the go dbus bindings and pflags for command-line arguments.
+Available on the AUR as [waybar-mpris-git](https://aur.archlinux.org/packages/waybar-mpris-git/) (Thanks @nichobi!)
 
-or just grab the `waybar-mpris` binary from here and place it in your PATH.
+Available on my Debian repo as well:
+```sh
+sudo apt-get update && sudo apt-get install curl apt-transport-https gnupg
+curl https://apt.hrfee.dev/hrfee.pubkey.gpg | sudo apt-key add -
+echo "deb https://apt.hrfee.dev trusty-unstable main" | sudo tee /etc/apt/sources.list.d/hrfee.list
+sudo apt-get update
+sudo apt-get install waybar-mpris
+```
 
+`go get git.hrfee.pw/hrfee/waybar-mpris` will compile from source and install.
+
+You can also download a precompiled binary from [here](https://builds2.hrfee.pw/view/hrfee/waybar-mpris).
+
+## Issues
+Stick them on [mpris2client](https://github.com/hrfee/mpris2client) or the [og](https://github.com/hrfee/waybar-mpris) repository (both on github) if you can't make an account here.
 ## Usage
 When running, the program will pipe out json in waybar's format. Add something like this to your waybar `config.json`:
 ```
@@ -42,10 +59,12 @@ When running, the program will pipe out json in waybar's format. Add something l
 ```
 Usage of waybar-mpris:
       --autofocus          Auto switch to currently playing music players.
+      --interpolate        Interpolate track position (helpful for players that don't update regularly, e.g mpDris2)
       --order string       Element order. (default "SYMBOL:ARTIST:ALBUM:TITLE:POSITION")
       --pause string       Pause symbol/text to use. (default "\uf8e3")
       --play string        Play symbol/text to use. (default "▶")
       --position           Show current position between brackets, e.g (04:50/05:00)
+      --replace            Replace any running instances
       --send string        send command to already runnning waybar-mpris instance. (options: player-next/player-prev/next/prev/toggle)
       --separator string   Separator string to use between artist, album, and title. (default " - ")
 ```
@@ -55,10 +74,12 @@ Usage of waybar-mpris:
 * `--separator` specifies a string to separate the artist, album and title text.
 * `--autofocus` makes waybar-mpris automatically focus on currently playing music players.
 * `--position` enables the display of the track position.
+* `--interpolate` increments the track position every second. This is useful for players (e.g mpDris2) that don't regularly update the position.
+* `--replace`: By default, new instances will attach to the existing one so that the output is identical. This lets this instance replace any others running. It isn't recommended. 
 * `--send` sends commands to an already running waybar-mpris instance via a unix socket. Commands:
   * `player-next`: Switch to displaying and controlling next available player.
   * `player-prev`: Same as `player-next`, but for the previous player.
   * `next/prev`: Next/previous track on the selected player.
   * `toggle`: Play/pause.
-  * *Note: you can also bind these commands to keys in your sway/other wm config.*
+  * You can also bind these commands to Media keys in your WM config.
 

go.mod

@@ -3,6 +3,9 @@ module git.hrfee.pw/hrfee/waybar-mpris
 go 1.15
 
 require (
+	github.com/fsnotify/fsnotify v1.4.9
 	github.com/godbus/dbus/v5 v5.0.3
+	github.com/hrfee/mpris2client v0.0.5
 	github.com/spf13/pflag v1.0.5
+	golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78 // indirect
 )

go.sum

@@ -1,4 +1,11 @@
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/godbus/dbus/v5 v5.0.3 h1:ZqHaoEF7TBzh4jzPmqVhE/5A1z9of6orkAe5uHoAeME=
 github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/hrfee/mpris2client v0.0.5 h1:h3gcb8Q68i6SfcEgOxL9cXcGee9ekvxXltrUxGwRLDU=
+github.com/hrfee/mpris2client v0.0.5/go.mod h1:tVpzzAlsljmQevNA4mJwUy1onUUiaQcRAa4gdl37okY=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78 h1:nVuTkr9L6Bq62qpUqKo/RnZCFfzDBL0bYo6w9OJUqZY=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

main.go

@@ -1,211 +1,205 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net"
 	"os"
-	"sort"
+	"os/signal"
 	"strconv"
 	"strings"
 	"time"
 
+	"github.com/fsnotify/fsnotify"
 	"github.com/godbus/dbus/v5"
+	mpris2 "github.com/hrfee/mpris2client"
 	flag "github.com/spf13/pflag"
 )
 
-var knownPlayers = map[string]string{
-	"plasma-browser-integration": "Browser",
-	"noson":                      "Noson",
-}
-
-var knownBrowsers = map[string]string{
-	"mozilla":  "Firefox",
-	"chrome":   "Chrome",
-	"chromium": "Chromium",
-}
-
-type Player struct {
-	player                               dbus.BusObject
-	fullName, name, title, artist, album string
-	pid                                  uint32
-	playing, stopped                     bool
-	metadata                             map[string]dbus.Variant
-	conn                                 *dbus.Conn
-}
-
+// Various paths and values to use elsewhere.
 const (
-	INTERFACE = "org.mpris.MediaPlayer2"
-	PATH      = "/org/mpris/MediaPlayer2"
-	// NameOwnerChanged
-	MATCH_NOC = "type='signal',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged'"
-	// PropertiesChanged
-	MATCH_PC = "type='signal',path='/org/mpris/MediaPlayer2',interface='org.freedesktop.DBus.Properties'"
 	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
 )
 
-// NewPlayer returns a new player object.
-func NewPlayer(conn *dbus.Conn, name string) (p *Player) {
-	playerName := strings.ReplaceAll(name, INTERFACE+".", "")
-	var pid uint32
-	conn.BusObject().Call("org.freedesktop.DBus.GetConnectionUnixProcessID", 0, name).Store(&pid)
-	for key, val := range knownPlayers {
-		if strings.Contains(name, key) {
-			playerName = val
-			if val == "Browser" {
-				file, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/cmdline", pid))
-				if err == nil {
-					cmd := string(file)
-					for k, v := range knownBrowsers {
-						if strings.Contains(cmd, k) {
-							playerName = v
-							break
+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
 	}
-					}
-				}
-			}
-			break
-		}
-	}
-	p = &Player{
-		player:   conn.Object(name, PATH),
-		conn:     conn,
-		name:     playerName,
-		fullName: name,
-		pid:      pid,
-	}
-	p.Refresh()
-	return
+	return ""
 }
 
-// Refresh grabs playback info.
-func (p *Player) Refresh() (err error) {
-	val, err := p.player.GetProperty(INTERFACE + ".Player.PlaybackStatus")
-	if err != nil {
-		p.playing = false
-		p.stopped = false
-		p.metadata = map[string]dbus.Variant{}
-		p.title = ""
-		p.artist = ""
-		p.album = ""
-		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
 		}
-	strVal := val.String()
-	if strings.Contains(strVal, "Playing") {
-		p.playing = true
-		p.stopped = false
-	} else if strings.Contains(strVal, "Paused") {
-		p.playing = false
-		p.stopped = false
+		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.stopped = true
+		p.Playing = false
 	}
-	metadata, err := p.player.GetProperty(INTERFACE + ".Player.Metadata")
-	if err != nil {
-		p.metadata = map[string]dbus.Variant{}
-		p.title = ""
-		p.artist = ""
-		p.album = ""
-		return
-	}
-	p.metadata = metadata.Value().(map[string]dbus.Variant)
-	switch artist := p.metadata["xesam:artist"].Value().(type) {
-	case []string:
-		p.artist = strings.Join(artist, ", ")
-	case string:
-		p.artist = artist
-	default:
-		p.artist = ""
-	}
-	switch title := p.metadata["xesam:title"].Value().(type) {
-	case string:
-		p.title = title
-	default:
-		p.title = ""
-	}
-	switch album := p.metadata["xesam:album"].Value().(type) {
-	case string:
-		p.album = album
-	default:
-		p.album = ""
-	}
-	return nil
+	p.Artist = values[3]
+	p.Album = values[4]
+	p.Title = values[5]
+	p.Name = values[6]
 }
 
-func µsToString(µs int64) string {
-	seconds := int(µs / 1e6)
+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 -= minutes * 60
+	seconds -= int(minutes * 60)
 	return fmt.Sprintf("%02d:%02d", minutes, seconds)
 }
 
-func (p *Player) Position() string {
-	// position is in microseconds so we prob need int64 to be safe
-	l := p.metadata["mpris:length"].Value().(int64)
-	length := µsToString(l)
-	if length == "" {
-		return ""
-	}
-	pos, err := p.player.GetProperty(INTERFACE + ".Player.Position")
-	if err != nil {
-		return ""
-	}
-	position := µsToString(pos.Value().(int64))
-	if position == "" {
-		return ""
-	}
-	return position + "/" + length
-}
-
-func (p *Player) JSON() string {
-	data := map[string]string{}
+// JSON returns json for waybar to consume.
+func playerJSON(p *player) string {
+	artist := strings.ReplaceAll(p.Artist, "\"", "\\\"")
+	album := strings.ReplaceAll(p.Album, "\"", "\\\"")
+	title := strings.ReplaceAll(p.Title, "\"", "\\\"")
+	name := strings.ReplaceAll(p.Name, "\"", "\\\"")
 	symbol := PLAY
-	data["class"] = "paused"
-	if p.playing {
+	out := "{\"class\": \""
+	if p.Playing {
 		symbol = PAUSE
-		data["class"] = "playing"
+		out += "playing"
+	} else {
+		out += "paused"
 	}
 	var pos string
 	if SHOW_POS {
-		pos = p.Position()
+		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 {
-		if v == "SYMBOL" {
+		switch v {
+		case "SYMBOL":
 			items = append(items, symbol)
-		} else if v == "ARTIST" {
-			if p.artist != "" {
-				items = append(items, p.artist)
+		case "ARTIST":
+			if artist != "" {
+				items = append(items, artist)
 			}
-		} else if v == "ALBUM" {
-			if p.album != "" {
-				items = append(items, p.album)
+		case "ALBUM":
+			if album != "" {
+				items = append(items, album)
 			}
-		} else if v == "TITLE" {
-			if p.title != "" {
-				items = append(items, p.title)
+		case "TITLE":
+			if title != "" {
+				items = append(items, title)
 			}
-		} else if v == "POSITION" && SHOW_POS {
-			if pos != "" {
+		case "POSITION":
+			if pos != "" && SHOW_POS {
 				items = append(items, pos)
 			}
+		case "PLAYER":
+			if name != "" {
+				items = append(items, name)
+			}
 		}
 	}
 	if len(items) == 0 {
@@ -223,286 +217,433 @@ func (p *Player) JSON() string {
 		}
 		text += v + right
 	}
-
-	data["tooltip"] = fmt.Sprintf(
-		"%s\nby %s\n",
-		p.title,
-		p.artist)
-	if p.album != "" {
-		data["tooltip"] += "from " + p.album + "\n"
+	out += "\",\"text\":\"" + text + "\","
+	out += "\"tooltip\":\"" + strings.ReplaceAll(title, "&", "&") + "\\n"
+	if artist != "" {
+		out += "by " + strings.ReplaceAll(artist, "&", "&") + "\\n"
 	}
-	data["tooltip"] += "(" + p.name + ")"
-	data["text"] = text
-	out, err := json.Marshal(data)
-	if err != nil {
-		return "{}"
+	if album != "" {
+		out += "from " + strings.ReplaceAll(album, "&", "&") + "\\n"
 	}
-	return string(out)
+	out += "(" + 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 PlayerList struct {
-	list    List
-	current uint
-	conn    *dbus.Conn
+type players struct {
+	mpris2 *mpris2.Mpris2
 }
 
-type List []*Player
-
-func (ls List) Len() int {
-	return len(ls)
-}
-
-func (ls List) Less(i, j int) bool {
-	var states [2]uint8
-	for i, p := range []bool{ls[i].playing, ls[j].playing} {
-		if p {
-			states[i] = 1
-		}
-	}
-	// Reverse order
-	return states[0] > states[1]
-}
-
-func (ls List) Swap(i, j int) {
-	ls[i], ls[j] = ls[j], ls[i]
-}
-
-func (pl *PlayerList) Remove(fullName string) {
-	currentName := pl.list[pl.current].fullName
-	var i int
-	found := false
-	for ind, p := range pl.list {
-		if p.fullName == fullName {
-			i = ind
-			found = true
-			break
-		}
-	}
-	if found {
-		pl.list[0], pl.list[i] = pl.list[i], pl.list[0]
-		pl.list = pl.list[1:]
-		found = false
-		for ind, p := range pl.list {
-			if p.fullName == currentName {
-				pl.current = uint(ind)
-				found = true
-				break
-			}
-		}
-		if !found {
-			pl.current = 0
-			pl.Refresh()
-			fmt.Println(pl.JSON())
-		}
-	}
-	// ls[len(ls)-1], ls[i] = ls[i], ls[len(ls)-1]
-	// ls = ls[:len(ls)-1]
-}
-
-func (pl *PlayerList) Reload() error {
-	var buses []string
-	err := pl.conn.BusObject().Call("org.freedesktop.DBus.ListNames", 0).Store(&buses)
-	if err != nil {
-		return err
-	}
-	for _, name := range buses {
-		// Don't add playerctld, it just duplicates other players
-		if strings.HasPrefix(name, INTERFACE) && !strings.Contains(name, "playerctld") {
-			pl.New(name)
-		}
-	}
-	return nil
-}
-
-func (pl *PlayerList) New(name string) {
-	pl.list = append(pl.list, NewPlayer(pl.conn, name))
-	if AUTOFOCUS {
-		pl.current = uint(len(pl.list) - 1)
-	}
-}
-
-func (pl *PlayerList) Sort() {
-	sort.Sort(pl.list)
-	pl.current = 0
-}
-
-func (pl *PlayerList) Refresh() {
-	for i := range pl.list {
-		pl.list[i].Refresh()
-	}
-}
-
-func (pl *PlayerList) JSON() string {
-	if len(pl.list) != 0 {
-		return pl.list[pl.current].JSON()
+func (pl *players) JSON() string {
+	if len(pl.mpris2.List) != 0 {
+		return playerJSON(&player{pl.mpris2.List[pl.mpris2.Current], false})
 	}
 	return "{}"
 }
 
-func (pl *PlayerList) Next() {
-	pl.list[pl.current].player.Call(INTERFACE+".Player.Next", 0)
-}
+func (pl *players) Next() { pl.mpris2.List[pl.mpris2.Current].Next() }
 
-func (pl *PlayerList) Prev() {
-	pl.list[pl.current].player.Call(INTERFACE+".Player.Previous", 0)
-}
+func (pl *players) Prev() { pl.mpris2.List[pl.mpris2.Current].Previous() }
 
-func (pl *PlayerList) Toggle() {
-	pl.list[pl.current].player.Call(INTERFACE+".Player.PlayPause", 0)
-}
+func (pl *players) Toggle() { pl.mpris2.List[pl.mpris2.Current].Toggle() }
 
-func main() {
-	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.")
-	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)")
-	var command string
-	flag.StringVar(&command, "send", "", "send command to already runnning waybar-mpris instance. (options: "+strings.Join(COMMANDS, "/")+")")
-	flag.Parse()
-
-	if command != "" {
+func execCommand(cmd string) {
 	conn, err := net.Dial("unix", SOCK)
 	if err != nil {
 		log.Fatalln("Couldn't dial:", err)
 	}
-		_, err = conn.Write([]byte(command))
+	shortCmd := stringToCmd(cmd)
+	_, err = conn.Write([]byte(shortCmd))
 	if err != nil {
 		log.Fatalln("Couldn't send command")
 	}
 	fmt.Println("Sent.")
-		if command == "list" {
+	if cmd == "list" {
 		buf := make([]byte, 512)
 		nr, err := conn.Read(buf)
 		if err != nil {
-				log.Fatalf("Couldn't read response.")
+			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 {
-		conn, err := dbus.SessionBus()
+							fmt.Print(str)
+						}
+						f.Seek(0, 0)
+					}
+				}
+			}
+		}
+	} else {
+		_, err := conn.Write([]byte(cDataShare))
 		if err != nil {
-			panic(err)
+			log.Fatalf("Couldn't send command: %v", err)
 		}
-		players := &PlayerList{
-			conn: conn,
+		buf = make([]byte, 2)
+		nr, err := conn.Read(buf)
+		if err != nil {
+			log.Fatalf("Couldn't read response: %v", err)
 		}
-		players.Reload()
-		players.Sort()
-		players.Refresh()
-		fmt.Println(players.JSON())
-		lastLine := ""
-		// fmt.Println("New array", players)
-		// Start command listener
-		go func() {
-			os.Remove(SOCK)
+		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.Fatalln("Couldn't establish socket connection at", SOCK)
+		log.Fatalf("Couldn't establish socket connection at %s (error %s)\n", SOCK, err)
 	}
-			defer listener.Close()
+	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, 512)
+		buf := make([]byte, 2)
 		nr, err := con.Read(buf)
 		if err != nil {
 			log.Println("Couldn't read:", err)
 			continue
 		}
 		command := string(buf[0:nr])
-				if command == "player-next" {
-					if players.current < uint(len(players.list)-1) {
-						players.current += 1
+		switch command {
+		case cPlayerNext:
+			length := len(players.mpris2.List)
+			if length != 1 {
+				if players.mpris2.Current < uint(length-1) {
+					players.mpris2.Current++
 				} else {
-						players.current = 0
+					players.mpris2.Current = 0
 				}
-					players.Refresh()
-					fmt.Println(players.JSON())
-				} else if command == "player-prev" {
-					if players.current != 0 {
-						players.current -= 1
+				players.mpris2.Refresh()
+			}
+		case cPlayerPrev:
+			length := len(players.mpris2.List)
+			if length != 1 {
+				if players.mpris2.Current != 0 {
+					players.mpris2.Current--
 				} else {
-						players.current = uint(len(players.list) - 1)
+					players.mpris2.Current = uint(length - 1)
 				}
-					players.Refresh()
-					fmt.Println(players.JSON())
-				} else if command == "next" {
+				players.mpris2.Refresh()
+			}
+		case cNext:
 			players.Next()
-				} else if command == "prev" {
+		case cPrev:
 			players.Prev()
-				} else if command == "toggle" {
+		case cToggle:
 			players.Toggle()
-				} else if command == "list" {
-					resp := ""
-					pad := 0
-					i := len(players.list)
-					for i != 0 {
-						i /= 10
-						pad++
+		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)
 				}
-					for i, p := range players.list {
-						symbol := ""
-						if uint(i) == players.current {
-							symbol = "*"
+				DATAWRITER = dataWrite{
+					emptyEveryWrite{file: f},
+					players,
 				}
-						resp += fmt.Sprintf("%0"+strconv.Itoa(pad)+"d%s: Name: %s; Playing: %t; PID: %d\n", i, symbol, p.fullName, p.playing, p.pid)
-					}
-					con.Write([]byte(resp))
+				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(&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)
 				}
 			}()
-
-		conn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, MATCH_NOC)
-		conn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, MATCH_PC)
+			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 SHOW_POS {
 		go func() {
 			for {
-					time.Sleep(1000 * time.Millisecond)
-					if players.list[players.current].playing {
-						go fmt.Println(players.JSON())
+				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())
+					}
 				}
 			}
 		}()
 	}
-		c := make(chan *dbus.Signal, 10)
-		conn.Signal(c)
-		for v := range c {
-			// fmt.Printf("SIGNAL: Sender %s, Path %s, Name %s, Body %s\n", v.Sender, v.Path, v.Name, v.Body)
-			if strings.Contains(v.Name, "NameOwnerChanged") {
-				switch name := v.Body[0].(type) {
-				case string:
-					var pid uint32
-					conn.BusObject().Call("org.freedesktop.DBus.GetConnectionUnixProcessID", 0, name).Store(&pid)
-					// Ignore playerctld again
-					if strings.Contains(name, INTERFACE) && !strings.Contains(name, "playerctld") {
-						if pid == 0 {
-							// fmt.Println("Removing", name)
-							players.Remove(name)
-						} else {
-							// fmt.Println("Adding", name)
-							players.New(name)
-						}
-					}
-				}
-			} else if strings.Contains(v.Name, "PropertiesChanged") && strings.Contains(v.Body[0].(string), INTERFACE+".Player") {
-				players.Refresh()
+	fmt.Fprintln(WRITER, players.JSON())
+	for v := range players.mpris2.Messages {
+		if v.Name == "refresh" {
 			if AUTOFOCUS {
-					players.Sort()
+				players.mpris2.Sort()
 			}
 			if l := players.JSON(); l != lastLine {
 				lastLine = l
-					fmt.Println(l)
-				}
+				fmt.Fprintln(WRITER, l)
 			}
 		}
 	}
+	players.mpris2.Refresh()
 }

version.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+NFPM_EPOCH=$(git rev-list --all --count) $@