353 lines
7.2 KiB
Python
353 lines
7.2 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# Author: coderkun <olli@coderkun.de>
|
|
|
|
|
|
|
|
|
|
import mpd
|
|
import os
|
|
from hashlib import md5
|
|
from threading import Thread
|
|
|
|
class MCGClient:
|
|
"""Client library for handling the connection to the Music Player Daemon.
|
|
|
|
This class implements an album-based MPD client.
|
|
It offers a non-blocking threaded worker model for use in graphical
|
|
environments and is based on python-mpd2.
|
|
"""
|
|
# Signal: connect/disconnect event
|
|
SIGNAL_CONNECT = 'connect'
|
|
# Signal: general idle event
|
|
SIGNAL_IDLE = 'idle'
|
|
# Signal: player idle event
|
|
SIGNAL_IDLE_PLAYER = 'idle_player'
|
|
# Signal: update event
|
|
SIGNAL_UPDATE = 'update'
|
|
|
|
|
|
def __init__(self):
|
|
"""Sets class variables and instantiates the MPDClient.
|
|
"""
|
|
self._connected = False
|
|
self._albums = {}
|
|
self._callbacks = {}
|
|
self._actions = []
|
|
self._worker = None
|
|
self._client = mpd.MPDClient()
|
|
self._go = True
|
|
|
|
|
|
def connect(self, host="localhost", port="6600", password=None):
|
|
"""Connects to MPD with the given host, port and password or
|
|
with standard values.
|
|
"""
|
|
self._add_action(self._connect, host, port, password)
|
|
|
|
|
|
def is_connected(self):
|
|
"""Returns the connection status.
|
|
"""
|
|
return self._connected
|
|
|
|
|
|
def disconnect(self):
|
|
"""Disconnects from the connected MPD.
|
|
"""
|
|
self._add_action(self._disconnect)
|
|
|
|
|
|
def close(self):
|
|
"""Closes the connection and stops properly the worker thread.
|
|
This method is to stop the whole appliction.
|
|
"""
|
|
if not self.is_connected():
|
|
return
|
|
try:
|
|
self._go = False
|
|
self._client.noidle()
|
|
self._client.disconnect()
|
|
except TypeError as e:
|
|
pass
|
|
|
|
|
|
def update(self):
|
|
"""Updates the album list.
|
|
"""
|
|
self._add_action(self._update)
|
|
|
|
|
|
def play(self, album):
|
|
"""Plays the given album.
|
|
"""
|
|
self._add_action(self._play, album)
|
|
|
|
|
|
def connect_signal(self, signal, callback):
|
|
"""Connects a callback function to a signal (event).
|
|
"""
|
|
self._callbacks[signal] = callback
|
|
|
|
|
|
def _has_callback(self, signal):
|
|
"""Checks if there is a registered callback function for a
|
|
signal.
|
|
"""
|
|
return signal in self._callbacks
|
|
|
|
|
|
def _callback(self, signal, *args):
|
|
"""Calls the callback function for a signal.
|
|
"""
|
|
if self._has_callback(signal):
|
|
callback = self._callbacks[signal]
|
|
callback(*args)
|
|
|
|
|
|
def _add_action(self, method, *args):
|
|
"""Adds an action to the action list.
|
|
"""
|
|
action = [method, args]
|
|
self._actions.append(action)
|
|
self._start_worker()
|
|
|
|
|
|
def _start_worker(self):
|
|
"""Starts the worker thread which waits for action to be
|
|
performed.
|
|
"""
|
|
if self._worker is None or not self._worker.is_alive():
|
|
self._worker = Thread(target=self._work, name='worker', args=())
|
|
self._worker.start()
|
|
else:
|
|
try:
|
|
self._client.noidle()
|
|
except TypeError as e:
|
|
pass
|
|
|
|
|
|
def _work(self):
|
|
"""Performs the next action or waits for an idle event.
|
|
"""
|
|
while True:
|
|
if self._actions:
|
|
action = self._actions.pop(0)
|
|
method = action[0]
|
|
params = action[1]
|
|
method(*params)
|
|
else:
|
|
if not self.is_connected():
|
|
break
|
|
modules = self._client.idle()
|
|
if not self._go:
|
|
break
|
|
self._idle(modules)
|
|
|
|
|
|
def _connect(self, host, port, password):
|
|
"""Action: Performs the real connect to MPD.
|
|
"""
|
|
try:
|
|
self._client.connect(host, port)
|
|
if password:
|
|
self._client.password(password)
|
|
# TODO Verbindung testen
|
|
self._connected = True
|
|
self._callback(self.SIGNAL_CONNECT, self._connected, None)
|
|
self.update()
|
|
self._add_action(self._idle_player)
|
|
except IOError as e:
|
|
self._connected = False
|
|
self._callback(self.SIGNAL_CONNECT, self._connected, e)
|
|
|
|
|
|
def _disconnect(self):
|
|
"""Action: Performs the real disconnect from MPD.
|
|
"""
|
|
if not self.is_connected():
|
|
return
|
|
try:
|
|
#self._client.close()
|
|
self._client.disconnect()
|
|
except:
|
|
self._client = mpd.MPDClient()
|
|
self._connected = False
|
|
self._callback(self.SIGNAL_CONNECT, self._connected, None)
|
|
|
|
|
|
def _update(self):
|
|
"""Action: Performs the real update.
|
|
"""
|
|
for song in self._client.listallinfo():
|
|
try:
|
|
hash = MCGAlbum.hash(song['artist'], song['album'])
|
|
if hash in self._albums.keys():
|
|
album = self._albums[hash]
|
|
else:
|
|
album = MCGAlbum(song['artist'], song['album'], song['date'], os.path.dirname(song['file']))
|
|
self._albums[album.get_hash()] = album
|
|
track = MCGTrack(song['title'], song['track'], song['time'], song['file'])
|
|
album.add_track(track)
|
|
except KeyError:
|
|
pass
|
|
# TODO Alben sortieren
|
|
self._callback(self.SIGNAL_UPDATE, self._albums)
|
|
|
|
|
|
def _play(self, album):
|
|
"""Action: Performs the real play command.
|
|
"""
|
|
track_ids = []
|
|
for track in self._albums[album].get_tracks():
|
|
track_id = self._client.addid(track.get_file())
|
|
track_ids.append(track_id)
|
|
self._client.moveid(track_id, len(track_ids)-1)
|
|
self._client.playid(track_ids[0])
|
|
|
|
|
|
def _idle(self, modules):
|
|
"""Reacts to idle events from MPD.
|
|
"""
|
|
if not modules:
|
|
return
|
|
|
|
if 'player' in modules:
|
|
self._idle_player()
|
|
if 'database' in modules:
|
|
# TODO update DB
|
|
pass
|
|
if 'update' in modules:
|
|
# TODO update
|
|
pass
|
|
if 'mixer' in modules:
|
|
# TODO mixer
|
|
pass
|
|
|
|
|
|
def _idle_player(self):
|
|
"""Reacts on the player idle event.
|
|
"""
|
|
if not self._has_callback(self.SIGNAL_IDLE_PLAYER):
|
|
return
|
|
status = self._client.status()
|
|
state = status['state']
|
|
song = self._client.currentsong()
|
|
album = None
|
|
if song:
|
|
album = MCGAlbum(song['artist'], song['album'], song['date'], os.path.dirname(song['file']))
|
|
self._callback(self.SIGNAL_IDLE_PLAYER, state, album)
|
|
|
|
|
|
def _idle_playlist(self):
|
|
""" Reacts on the playlist idle event.
|
|
"""
|
|
pass
|
|
|
|
|
|
|
|
|
|
class MCGAlbum:
|
|
_file_names = ['folder', 'cover']
|
|
_file_exts = ['jpg', 'jpeg', 'png']
|
|
|
|
|
|
def __init__(self, artist, title, date, path):
|
|
self._artist = artist
|
|
if type(self._artist) is list:
|
|
self._artist = self._artist[0]
|
|
self._title = title
|
|
self._date = date
|
|
self._path = path
|
|
self._tracks = []
|
|
self._cover = None
|
|
|
|
self._set_hash()
|
|
self._find_cover()
|
|
|
|
|
|
def get_artist(self):
|
|
return self._artist
|
|
|
|
|
|
def get_title(self):
|
|
return self._title
|
|
|
|
|
|
def get_date(self):
|
|
return self._date
|
|
|
|
|
|
def get_path(self):
|
|
return self._path
|
|
|
|
|
|
def add_track(self, track):
|
|
if track not in self._tracks:
|
|
self._tracks.append(track)
|
|
|
|
|
|
def get_tracks(self):
|
|
return self._tracks
|
|
|
|
|
|
def get_cover(self):
|
|
return self._cover
|
|
|
|
|
|
def _find_cover(self):
|
|
names = list(self._file_names)
|
|
names.append(self._title)
|
|
names.append(' - '.join((self._artist, self._title)))
|
|
|
|
|
|
for name in names:
|
|
for ext in self._file_exts:
|
|
filename = os.path.join('/home/oliver/Musik/', self._path, '.'.join([name, ext]))
|
|
if os.path.isfile(filename):
|
|
self._cover = filename
|
|
break
|
|
if self._cover is not None:
|
|
break
|
|
|
|
|
|
def hash(artist, title):
|
|
if type(artist) is list:
|
|
artist = artist[0]
|
|
return md5(artist.encode('utf-8')+title.encode('utf-8')).hexdigest()
|
|
|
|
|
|
def _set_hash(self):
|
|
self._hash = MCGAlbum.hash(self._artist, self._title)
|
|
|
|
|
|
def get_hash(self):
|
|
return self._hash
|
|
|
|
|
|
|
|
|
|
class MCGTrack:
|
|
def __init__(self, title, track, time, file):
|
|
self._title = title
|
|
self._track = track
|
|
self._time = time
|
|
self._file = file
|
|
|
|
|
|
def get_title(self):
|
|
return self._title
|
|
|
|
|
|
def get_track(self):
|
|
return self._track
|
|
|
|
|
|
def get_time(self):
|
|
return self._time
|
|
|
|
|
|
def get_file(self):
|
|
return self._file
|
|
|