awesome/widgets/mpc.lua

   1 -- Originally from https://awesomewm.org/recipes/mpc/
   2
   3 local lgi = require "lgi"
   4 local GLib = lgi.GLib
   5 local Gio = lgi.Gio
   6
   7 local mpc = {}
   8
   9 local function parse_password(host)
  10     -- This function is based on mpd_parse_host_password() from libmpdclient
  11     local position = string.find(host, "@")
  12     if not position then
  13         return host
  14     end
  15     return string.sub(host, position + 1), string.sub(host, 1, position - 1)
  16 end
  17
  18 function mpc.new(host, port, password, error_handler, ...)
  19     host = host or os.getenv("MPD_HOST") or "localhost"
  20     port = port or os.getenv("MPD_PORT") or 6600
  21     if not password then
  22         host, password = parse_password(host)
  23     end
  24     local self = setmetatable({
  25         _host = host,
  26         _port = port,
  27         _password = password,
  28         _error_handler = error_handler or function() end,
  29         _connected = false,
  30         _try_reconnect = false,
  31         _idle_commands = { ... }
  32     }, { __index = mpc })
  33     self:_connect()
  34     return self
  35 end
  36
  37 function mpc:_error(err)
  38     self._connected = false
  39     self._error_handler(err)
  40     self._try_reconnect = not self._try_reconnect
  41     if self._try_reconnect then
  42         self:_connect()
  43     end
  44 end
  45
  46 function mpc:_connect()
  47     if self._connected then return end
  48     -- Reset all of our state
  49     self._reply_handlers = {}
  50     self._pending_reply = {}
  51     self._idle_commands_pending = false
  52     self._idle = false
  53     self._connected = true
  54
  55     -- Set up a new connection
  56     local address
  57     if string.sub(self._host, 1, 1) == "/" then
  58         -- It's a unix socket
  59         address = Gio.UnixSocketAddress.new(self._host)
  60     else
  61         -- Do a TCP connection
  62         address = Gio.NetworkAddress.new(self._host, self._port)
  63     end
  64     local client = Gio.SocketClient()
  65     local conn, err = client:connect(address)
  66
  67     if not conn then
  68         self:_error(err)
  69         return false
  70     end
  71
  72     local input, output = conn:get_input_stream(), conn:get_output_stream()
  73     self._conn, self._output, self._input = conn, output, Gio.DataInputStream.new(input)
  74
  75     -- Read the welcome message
  76     self._input:read_line()
  77
  78     if self._password and self._password ~= "" then
  79         self:_send("password " .. self._password)
  80     end
  81
  82     -- Set up the reading loop. This will asynchronously read lines by
  83     -- calling itself.
  84     local do_read
  85     do_read = function()
  86         self._input:read_line_async(GLib.PRIORITY_DEFAULT, nil, function(obj, res)
  87             local line, err = obj:read_line_finish(res)
  88             -- Ugly API. On success we get string, length-of-string
  89             -- and on error we get nil, error. Other versions of lgi
  90             -- behave differently.
  91             if line == nil or tostring(line) == "" then
  92                 err = "Connection closed"
  93             end
  94             if type(err) ~= "number" then
  95                 self._output, self._input = nil, nil
  96                 self:_error(err)
  97             else
  98                 line = tostring(line)
  99                 if line == "OK" or line:match("^ACK ") then
 100                     local success = line == "OK"
 101                     local arg
 102                     if success then
 103                         arg = self._pending_reply
 104                     else
 105                         arg = { line }
 106                     end
 107                     local handler = self._reply_handlers[1]
 108                     table.remove(self._reply_handlers, 1)
 109                     self._pending_reply = {}
 110                     handler(success, arg)
 111                 else
 112                     local _, _, key, value = string.find(line, "([^:]+):%s(.+)")
 113                     if key then
 114                         if key == "binary" then
 115                             value = tonumber(value)
 116                             local data = {}
 117                             while value > 0 do
 118                                 local b = assert(obj:read_bytes(value))
 119                                 table.insert(data, b.data)
 120                                 value = value - #b
 121                             end
 122                             local w = obj:read_bytes(1)  -- read newline at end of binary
 123                             self._pending_reply[string.lower(key)] = table.concat(data)
 124                         else
 125                             self._pending_reply[string.lower(key)] = value
 126                         end
 127                     end
 128                 end
 129                 do_read()
 130             end
 131         end)
 132     end
 133     do_read()
 134
 135     -- To synchronize the state on startup, send the idle commands now. As a
 136     -- side effect, this will enable idle state.
 137     self:_send_idle_commands(true)
 138
 139     return self
 140 end
 141
 142 function mpc:_send_idle_commands(skip_stop_idle)
 143     -- We use a ping to unset this to make sure we never get into a busy
 144     -- loop sending idle / unidle commands. Next call to
 145     -- _send_idle_commands() might be ignored!
 146     if self._idle_commands_pending then
 147         return
 148     end
 149     if not skip_stop_idle then
 150         self:_stop_idle()
 151     end
 152
 153     self._idle_commands_pending = true
 154     for i = 1, #self._idle_commands, 2 do
 155         self:_send(self._idle_commands[i], self._idle_commands[i+1])
 156     end
 157     self:_send("ping", function()
 158         self._idle_commands_pending = false
 159     end)
 160     self:_start_idle()
 161 end
 162
 163 function mpc:_start_idle()
 164     if self._idle then
 165         error("Still idle?!")
 166     end
 167     self:_send("idle", function(success, reply)
 168         if reply.changed then
 169             -- idle mode was disabled by mpd
 170             self:_send_idle_commands()
 171         end
 172     end)
 173     self._idle = true
 174 end
 175
 176 function mpc:_stop_idle()
 177     if not self._idle then
 178         error("Not idle?!")
 179     end
 180     self._output:write("noidle\n")
 181     self._idle = false
 182 end
 183
 184 function mpc:_send(command, callback)
 185     if self._idle then
 186         error("Still idle in send()?!")
 187     end
 188     self._output:write(command .. "\n")
 189     table.insert(self._reply_handlers, callback or function() end)
 190 end
 191
 192 function mpc:send(...)
 193     self:_connect()
 194     if not self._connected then
 195         return
 196     end
 197     local args = { ... }
 198     if not self._idle then
 199         error("Something is messed up, we should be idle here...")
 200     end
 201     self:_stop_idle()
 202     for i = 1, #args, 2 do
 203         self:_send(args[i], args[i+1])
 204     end
 205     self:_start_idle()
 206 end
 207
 208 function mpc:toggle_play()
 209     self:send("status", function(success, status)
 210         if status.state == "stop" then
 211             self:send("play")
 212         else
 213             self:send("pause")
 214         end
 215     end)
 216 end
 217
 218 function clamp(x, min, max)
 219     return math.min(math.max(x, min), max)
 220 end
 221
 222 function mpc:change_volume(change)
 223     self:send("status", function(_, status)
 224         new_vol = clamp(tonumber(status.volume) + change, 0, 100)
 225         self:send("setvol " .. new_vol)
 226     end)
 227 end
 228
 229 function mpc:currentsong()
 230     local currentsong
 231     self:send("currentsong", function(err, song)
 232         if err then error(err) end
 233         currentsong = song
 234     end)
 235     return currentsong
 236 end
 237
 238 --[[
 239
 240 -- Example on how to use this (standalone)
 241
 242 local host, port, password = nil, nil, nil
 243 local m = mpc.new(host, port, password, error,
 244     "status", function(success, status) print("status is", status.state) end)
 245
 246 GLib.timeout_add(GLib.PRIORITY_DEFAULT, 1000, function()
 247     -- Test command submission
 248     m:send("status", function(_, s) print(s.state) end,
 249         "currentsong", function(_, s) print(s.title) end)
 250     m:send("status", function(_, s) print(s.state) end)
 251     -- Force a reconnect
 252     GLib.timeout_add(GLib.PRIORITY_DEFAULT, 1000, function()
 253         m._conn:close()
 254     end)
 255 end)
 256
 257 GLib.MainLoop():run()
 258 --]]
 259
 260 return mpc