Added Snapcast plugin

This commit is contained in:
Fabio Manganiello 2019-01-06 02:19:53 +01:00
parent cb13098c4f
commit e97ce5d676

View file

@ -0,0 +1,479 @@
import json
import socket
import threading
from platypush.plugins import Plugin, action
class MusicSnapcastPlugin(Plugin):
"""
Plugin to interact with a [Snapcast](https://github.com/badaix/snapcast)
instance, control clients mute status, volume, playback etc.
See https://github.com/badaix/snapcast/blob/master/doc/json_rpc_api/v2_0_0.md
for further reference about the returned API types.
"""
_DEFAULT_SNAPCAST_PORT = 1705
_SOCKET_EOL = '\r\n'.encode()
def __init__(self, host='localhost', port=_DEFAULT_SNAPCAST_PORT,
*args, **kwargs):
"""
:param host: Default Snapcast server host (default: localhost)
:type host: str
:param port: Default Snapcast server control port (default: 1705)
:type port: int
"""
super().__init__(*args, **kwargs)
self.host = host
self.port = port
self._latest_req_id = 0
self._latest_req_id_lock = threading.RLock()
def _get_req_id(self):
with self._latest_req_id_lock:
self._latest_req_id += 1
return self._latest_req_id
def _connect(self, host=None, port=None):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host or self.host, port or self.port))
return sock
@classmethod
def _send(cls, sock, req):
if isinstance(req, dict):
req = json.dumps(req)
if isinstance(req, str):
req = req.encode()
if not isinstance(req, bytes):
raise RuntimeError('Unsupported type {} for Snapcast request: {}'.
format(type(req), req))
sock.send(req + cls._SOCKET_EOL)
@classmethod
def _recv(cls, sock):
buf = b''
while buf[-2:] != cls._SOCKET_EOL:
buf += sock.recv(1)
return json.loads(buf.decode().strip()).get('result')
def _get_group_by_client(self, sock, client):
for g in self._status(sock).get('groups', []):
clients = g.get('clients', [])
for c in clients:
if client == c.get('id') or \
client == c.get('host', {}).get('name') or \
client == c.get('host', {}).get('ip'):
return g
def _get_group(self, sock, group):
for g in self._status(sock).get('groups', []):
if group == g.get('id') or group == g.get('name'):
return g
def _get_client(self, sock, client):
group = self._get_group_by_client(sock, client)
if not group:
return None
clients = group.get('clients', [])
return None if len(clients) == 0 else clients[0]
def _status(self, sock):
request = {
'id': self._get_req_id(),
'jsonrpc':'2.0',
'method':'Server.GetStatus'
}
self._send(sock, request)
return self._recv(sock).get('server', {})
@action
def status(self, host=None, port=None):
"""
Get the status either of a Snapcast server
:param host: Snapcast server to query (default: default configured host)
:type host: str
:param port: Snapcast server port (default: default configured port)
:type port: int
:returns: dict. Example::
"output": {
"groups": [
{
"clients": [
{
"config": {
"instance": 1,
"latency": 0,
"name": "",
"volume": {
"muted": false,
"percent": 96
}
},
"connected": true,
"host": {
"arch": "x86_64",
"ip": "YOUR_IP",
"mac": "YOUR_MAC",
"name": "YOUR_NAME",
"os": "YOUR_OS"
},
"id": "YOUR_ID",
"lastSeen": {
"sec": 1546648311,
"usec": 86011
},
"snapclient": {
"name": "Snapclient",
"protocolVersion": 2,
"version": "0.15.0"
}
}
],
"id": "YOUR_ID",
"muted": false,
"name": "",
"stream_id": "mopidy"
}
],
"server": {
"host": {
"arch": "armv7l",
"ip": "",
"mac": "",
"name": "YOUR_NAME",
"os": "YOUR_OS"
},
"snapserver": {
"controlProtocolVersion": 1,
"name": "Snapserver",
"protocolVersion": 1,
"version": "0.15.0"
}
},
"streams": [
{
"id": "mopidy",
"meta": {
"STREAM": "mopidy"
},
"status": "playing",
"uri": {
"fragment": "",
"host": "",
"path": "/tmp/snapfifo",
"query": {
"buffer_ms": "20",
"codec": "pcm",
"name": "mopidy",
"sampleformat": "48000:16:2"
},
"raw": "pipe:////tmp/snapfifo?buffer_ms=20&codec=pcm&name=mopidy&sampleformat=48000:16:2",
"scheme": "pipe"
}
}
]
}
"""
sock = None
try:
sock = self._connect(host or self.host, port or self.port)
return self._status(sock)
finally:
try: sock.close()
except: pass
@action
def mute(self, client=None, group=None, mute=None, host=None, port=None):
"""
Set the mute status of a connected client or group
:param client: Client name or ID to mute
:type client: str
:param group: Group ID to mute
:type group: str
:param mute: Mute status. If not set, the mute status of the selected
client/group will be toggled.
:type mute: bool
:param host: Snapcast server to query (default: default configured host)
:type host: str
:param port: Snapcast server port (default: default configured port)
:type port: int
"""
if not client and not group:
raise RuntimeError('Please specify either a client or a group')
sock = None
try:
sock = self._connect(host or self.host, port or self.port)
request = {
'id': self._get_req_id(),
'jsonrpc':'2.0',
'method': 'Group.SetMute' if group else 'Client.SetVolume',
'params': {}
}
if group:
group = self._get_group(sock, group)
cur_muted = group['muted']
request['params']['id'] = group['id']
request['params']['mute'] = not cur_muted if mute is None else mute
else:
client = self._get_client(sock, client)
cur_muted = client['config']['volume']['muted']
request['params']['id'] = client['id']
request['params']['volume'] = {}
request['params']['volume']['percent'] = client['config']['volume']['percent']
request['params']['volume']['muted'] = not cur_muted if mute is None else mute
self._send(sock, request)
return self._recv(sock)
finally:
try: sock.close()
except: pass
@action
def volume(self, client, volume=None, delta=None, mute=None, host=None,
port=None):
"""
Set the volume of a connected client
:param client: Client name or ID
:type client: str
:param volume: Absolute volume to set between 0 and 100
:type volume: int
:param delta: Relative volume change in percentage (e.g. +10 or -10)
:type delta: int
:param mute: Set to true or false if you want to toggle the muted status
:type mute: bool
:param host: Snapcast server (default: default configured host)
:type host: str
:param port: Snapcast server port (default: default configured port)
:type port: int
"""
if volume is None and delta is None and mute is None:
raise RuntimeError('Please specify either an absolute volume or ' +
'relative delta')
sock = None
try:
sock = self._connect(host or self.host, port or self.port)
request = {
'id': self._get_req_id(),
'jsonrpc':'2.0',
'method': 'Client.SetVolume',
'params': {}
}
client = self._get_client(sock, client)
cur_volume = int(client['config']['volume']['percent'])
cur_mute = bool(client['config']['volume']['muted'])
if volume is not None:
volume = int(volume)
elif delta is not None:
volume = cur_volume + int(delta)
if volume is not None:
if volume > 100: volume = 100
if volume < 0: volume = 0
else:
volume = cur_volume
if mute is None:
mute = cur_mute
request['params']['id'] = client['id']
request['params']['volume'] = {}
request['params']['volume']['percent'] = volume
request['params']['volume']['muted'] = mute
self._send(sock, request)
return self._recv(sock)
finally:
try: sock.close()
except: pass
@action
def set_client_name(self, client, name, host=None, port=None):
"""
Set/change the name of a connected client
:param client: Current client name or ID to rename
:type client: str
:param name: New name
:type name: str
:param host: Snapcast server (default: default configured host)
:type host: str
:param port: Snapcast server port (default: default configured port)
:type port: int
"""
sock = None
try:
sock = self._connect(host or self.host, port or self.port)
request = {
'id': self._get_req_id(),
'jsonrpc':'2.0',
'method': 'Client.SetName',
'params': {}
}
client = self._get_client(sock, client)
request['params']['id'] = client['id']
request['params']['name'] = name
self._send(sock, request)
return self._recv(sock)
finally:
try: sock.close()
except: pass
@action
def set_latency(self, client, latency, host=None, port=None):
"""
Set/change the latency of a connected client
:param client: Client name or ID
:type client: str
:param latency: New latency in milliseconds
:type latency: float
:param host: Snapcast server (default: default configured host)
:type host: str
:param port: Snapcast server port (default: default configured port)
:type port: int
"""
sock = None
try:
sock = self._connect(host or self.host, port or self.port)
request = {
'id': self._get_req_id(),
'jsonrpc':'2.0',
'method': 'Client.SetLatency',
'params': {
'latency': latency
}
}
client = self._get_client(sock, client)
request['params']['id'] = client['id']
self._send(sock, request)
return self._recv(sock)
finally:
try: sock.close()
except: pass
@action
def delete_client(self, client, host=None, port=None):
"""
Delete a client from the Snapcast server
:param client: Client name or ID
:type client: str
:param host: Snapcast server (default: default configured host)
:type host: str
:param port: Snapcast server port (default: default configured port)
:type port: int
"""
sock = None
try:
sock = self._connect(host or self.host, port or self.port)
request = {
'id': self._get_req_id(),
'jsonrpc':'2.0',
'method': 'Server.DeleteClient',
'params': {}
}
client = self._get_client(sock, client)
request['params']['id'] = client['id']
self._send(sock, request)
return self._recv(sock)
finally:
try: sock.close()
except: pass
@action
def group_set_clients(self, group, clients, host=None, port=None):
"""
Sets the clients for a group on a Snapcast server
:param group: Group name or ID
:type group: str
:param clients: List of client names or IDs
:type clients: list[str]
:param host: Snapcast server (default: default configured host)
:type host: str
:param port: Snapcast server port (default: default configured port)
:type port: int
"""
sock = None
try:
sock = self._connect(host or self.host, port or self.port)
request = {
'id': self._get_req_id(),
'jsonrpc':'2.0',
'method': 'Group.SetClients',
'params': {
'clients': []
}
}
for client in clients:
client = self._get_client(sock, client)
request['params']['clients'].append(client['id'])
self._send(sock, request)
return self._recv(sock)
finally:
try: sock.close()
except: pass
# vim:sw=4:ts=4:et: