def update():
instance = int(request.args.get("instance"))
if instance == 1:
Updater().update()
else:
APIController().slave_command(instance, "updater", "update")
return "OK"
def restart_device():
instance = int(request.args.get("instance"))
if instance == 1:
os.system('sudo reboot')
else:
APIController().slave_command(instance, "system", "restart_device")
return "OK"
def notify_next_episode(self, callback):
if self.next_type is not None:
Logger().write(
LogVerbosity.Info,
"Can continue with next episode: " + self.next_title)
APIController().ui_request("SelectNextEpisode", callback, 60 * 60,
self.next_title)
def _send_ui_request(topic, data, timeout):
Logger().write(LogVerbosity.Debug, "Sending ui request: " + topic + ", data: " + str(data))
request_id = APIController().next_id()
request = Request(request_id, topic, data, None, SlaveClientController._complete_request)
SlaveClientController.requests.append(request)
SlaveClientController.slave_ns.emit("ui_request", request_id, topic, data, timeout)
return request
def media_selection_required(self, files):
if Settings.get_bool("slave"):
data, = SlaveClientController.request_master(
"get_history_for_url", 5, self.torrent.uri)
if data:
history = [
History(x['id'], x['imdb_id'], x['type'], x['title'],
x['image'], x['watched_at'], x['season'],
x['episode'], x['url'], x['media_file'],
x['played_for'], x['length'])
for x in json.loads(data)
]
else:
history = []
else:
history = Database().get_history_for_url(self.torrent.uri)
for file in files:
seen = [x for x in history if x.media_file == file.path]
file.seen = len(seen) > 0
if file.seen:
seen = seen[-1]
file.played_for = seen.played_for
file.play_length = seen.length
APIController().ui_request("SelectMediaFile", self.set_media_file,
60 * 30, files)
def _send_request(self, topic, data, room):
Logger().write(LogVerbosity.Debug, "Sending request: " + topic + ", data: " + str(data))
request_id = APIController().next_id()
request_message = Request(request_id, topic, data, room, self._complete_request)
self.requests.append(request_message)
data = to_JSON(data)
self.emit("request", (request_id, topic, data), room=room)
return request_message
def close_application():
instance = int(request.args.get("instance"))
if instance == 1:
sys.exit()
else:
APIController().slave_command(instance, "system",
"close_application")
return "OK"
def stop_player():
instance = int(request.args.get("instance"))
Logger().write(LogVerbosity.Info, "Stop playing on " + str(instance))
if instance == 1:
MediaManager().stop_play()
else:
APIController().slave_command(instance, "media", "stop_play")
return "OK"
def pause_resume_player():
instance = int(request.args.get("instance"))
Logger().write(LogVerbosity.Info, "Pause/resume on " + str(instance))
if instance == 1:
MediaManager().pause_resume()
else:
APIController().slave_command(instance, "media", "pause_resume")
return "OK"
def restart_application():
instance = int(request.args.get("instance"))
if instance == 1:
python = sys.executable
os.execl(python, python, *sys.argv)
else:
APIController().slave_command(instance, "system",
"restart_application")
return "OK"
def seek():
instance = int(request.args.get("instance"))
position = int(request.args.get("position"))
Logger().write(LogVerbosity.Info,
"Seek " + str(instance) + " to " + str(position))
if instance == 1:
MediaManager().seek(position)
else:
APIController().slave_command(instance, "media", "seek", position)
return "OK"
def get_update():
instance = int(request.args.get("instance"))
if instance == 1:
return to_JSON(
UpdateAvailable(Updater().check_version(),
Updater().last_version))
else:
result = APIController().slave_request(instance,
"get_last_version", 10)
if result is None:
return to_JSON(UpdateAvailable(False, ""))
return to_JSON(UpdateAvailable(result[0], result[1]))
def change_volume():
instance = int(request.args.get("instance"))
volume = int(request.args.get("volume"))
Logger().write(LogVerbosity.Info,
"Set volume on " + str(instance) + " to " + str(volume))
if instance == 1:
MediaManager().change_volume(volume)
else:
APIController().slave_command(instance, "media", "change_volume",
volume)
return "OK"
def change_audio():
instance = int(request.args.get("instance"))
track = int(request.args.get("track"))
Logger().write(LogVerbosity.Info,
"Set audio on " + str(instance) + " to " + str(track))
if instance == 1:
MediaManager().change_audio(track)
else:
APIController().slave_command(instance, "media", "change_audio",
track)
return "OK"
def play_radio():
radio_id = int(request.args.get("id"))
radio = [x for x in Database().get_radios() if x.id == radio_id][0]
instance = int(request.args.get("instance"))
Logger().write(LogVerbosity.Info,
"Play radio " + radio.title + " on " + str(instance))
if instance == 1:
MediaManager().start_radio(radio.title, radio.url)
else:
APIController().slave_command(instance, "media", "start_radio",
radio.title, radio.url)
return "OK"
def change_sub_delay():
instance = int(request.args.get("instance"))
delay = int(request.args.get("delay"))
Logger().write(
LogVerbosity.Info,
"Set sub delay on " + str(instance) + " to " + str(delay))
if instance == 1:
MediaManager().change_subtitle_delay(delay)
else:
APIController().slave_command(instance, "media",
"change_subtitle_delay", delay)
return "OK"
def play_youtube():
instance = int(request.args.get("instance"))
title = urllib.parse.unquote(request.args.get("title"))
url = urllib.parse.unquote(request.args.get("url"))
position = int(request.args.get("position"))
Logger().write(LogVerbosity.Info,
"Play youtube " + title + " on " + str(instance))
if instance == 1:
MediaManager().start_youtube(title, url, position)
else:
APIController().slave_command(instance, "media", "start_youtube",
title, url, position)
return "OK"
def on_ui_request(request_id, topic, data, timeout):
slave = APIController.slaves.get_slave_by_sid(request.sid)
if slave is None:
Logger().write(LogVerbosity.Debug,
"Slave ui request for not initialized slave")
disconnect()
return
Logger().write(LogVerbosity.Debug,
"Slave ui request " + topic + ": " + data)
slave = APIController.slaves.get_slave_by_sid(request.sid)
APIController().ui_request(
topic,
lambda *x: SlaveWebsocketController.slave_ui_request_callback(
request_id, slave, x), timeout, json.loads(data))
def on_get_current_requests():
authenticated = [
x for x in UIWebsocketController.clients if x.sid == request.sid
][0].authenticated
if not authenticated:
Logger().write(
LogVerbosity.Info,
"Unauthenticated socket request for current requests")
return
for client_request in APIController().ui_websocket_controller.requests:
socketio.emit("request",
(client_request.request_id, client_request.topic,
to_JSON(client_request.data)),
namespace="/UI",
room=request.sid)
def play_file():
instance = int(request.args.get("instance"))
position = int(request.args.get("position"))
file = urllib.parse.unquote(request.args.get("path"))
if sys.platform == "win32":
file = "C:" + file
Logger().write(LogVerbosity.Info,
"Play file " + file + " on " + str(instance))
if instance == 1:
MediaManager().start_file(file, position)
else:
APIController().slave_command(instance, "media", "start_file",
file, position)
return "OK"
def play_url():
instance = int(request.args.get("instance"))
title = urllib.parse.unquote(request.args.get("title"))
url = urllib.parse.unquote(request.args.get("url"))
Logger().write(
LogVerbosity.Info,
"Play url " + title + "(" + url + ") on " + str(instance))
if instance == 1:
if url.startswith("magnet:"):
MediaManager().start_torrent(title, url, None)
else:
MediaManager().start_url(title, url)
else:
APIController().slave_command(instance, "media", "start_url",
title, url)
return "OK"
def play_torrent():
instance = int(request.args.get("instance"))
title = urllib.parse.unquote(request.args.get("title"))
url = urllib.parse.unquote(request.args.get("url"))
magnet_uri = TorrentController.get_magnet_url(url)
if magnet_uri is None:
Logger().write(LogVerbosity.Error,
"Failed to find torrent magnet uri")
return "OK"
Logger().write(LogVerbosity.Info,
"Play torrent " + title + " on " + str(instance))
if instance == 1:
MediaManager().start_torrent(title, magnet_uri)
else:
APIController().slave_command(instance, "media", "start_torrent",
title, magnet_uri)
return "OK"
def play_episode():
instance = int(request.args.get("instance"))
title = urllib.parse.unquote(request.args.get("title"))
movie_id = request.args.get("id")
url = urllib.parse.unquote(request.args.get("url"))
img = urllib.parse.unquote(request.args.get("img"))
position = int(request.args.get("position"))
season = int(request.args.get("season"))
episode = int(request.args.get("episode"))
Logger().write(LogVerbosity.Info,
"Play episode " + title + " on " + str(instance))
if instance == 1:
MediaManager().start_episode(movie_id, season, episode, title, url,
img, position)
else:
APIController().slave_command(instance, "media", "start_episode",
movie_id, season, episode, title,
url, img, position)
return "OK"
def __init__(self):
Logger().start(Settings.get_int("log_level"))
sys.excepthook = self.handle_exception
Logger().write(LogVerbosity.Info, "Starting")
self.running = True
self.version = datetime.fromtimestamp(
self.get_latest_change()).strftime("%Y-%m-%d %H:%M:%S")
self.is_slave = Settings.get_bool("slave")
self.pi = sys.platform == "linux" or sys.platform == "linux2"
Logger().write(
LogVerbosity.Info, "Python version " + str(sys.version_info[0]) +
"." + str(sys.version_info[1]) + "." + str(sys.version_info[2]))
Logger().write(LogVerbosity.Info,
"MediaPlayer build [" + self.version + "]")
Logger().write(LogVerbosity.Info, "Slave: " + str(self.is_slave))
if self.is_slave:
Logger().write(
LogVerbosity.Info,
"Master ip: " + str(Settings.get_string("master_ip")))
Logger().write(LogVerbosity.Info, "Pi: " + str(self.pi))
Logger().write(LogVerbosity.Info,
"UI: " + str(Settings.get_bool("UI")))
Logger().write(LogVerbosity.Debug, "Initializing database")
Database().init_database()
Logger().write(LogVerbosity.Debug, "Initializing singletons")
self.init_singletons()
Logger().write(LogVerbosity.Debug, "Initializing sounds and folders")
self.init_sound()
self.init_folders()
Logger().write(LogVerbosity.Debug, "Initializing API")
APIController().start()
Logger().write(LogVerbosity.Debug, "Initializing WiFi controller")
WiFiController().check_wifi()
Logger().write(LogVerbosity.Debug, "Initializing stats")
Stats().start()
Stats().set('start_time', current_time())
Logger().write(LogVerbosity.Debug, "Initializing presence manager")
PresenceManager().start()
Logger().write(LogVerbosity.Debug, "Initializing rule manager")
RuleManager().start()
Logger().write(LogVerbosity.Debug, "Initializing TV manager")
TVManager().start()
if not self.is_slave:
Logger().write(LogVerbosity.Debug, "Initializing TradeFriManager")
TradfriManager().init()
Logger().write(LogVerbosity.Debug,
"Initializing master file server")
self.file_listener = StreamListener("MasterFileServer", 50015)
self.file_listener.start_listening()
Logger().write(LogVerbosity.Important, "Started")
if Settings.get_bool("UI"):
from UI.TV.GUI import App
self.gui = App.initialize()
else:
while self.running:
time.sleep(5)
def on_ui_message(title, message):
APIController().ui_message(title, message)
def aborting_torrent(self, reason):
APIController().ui_message("Aborting torrent", reason)
self.stop_play()