def loop_track(self):
time_before_loop = self.loop_b - self.loop_a
self.schedule_looping_task(time_before_loop)
logger.debug('Setting player time to {}'.format(self.loop_a))
self.player.set_time(int(self.loop_a * 1000))
self.loop_callback(self.track_id)
def cancel_looping_task(self):
logger.debug('Cancelling looping task')
try:
self.looping_task.cancel()
except Exception as e:
logger.warning(
"Could not cancel looping task (reason={})".format(e))
def new_player(self):
super(VLCLoopingChapterVideoPlayer, self).new_player()
logger.debug('Setting time={} because current chapter is {}'.format(
self.current_chapter['t_start'], self.current_chapter_id))
# callLater because VLC seems to need some delay
reactor.callLater(0.01, self.player.set_time,
int(self.current_chapter['t_start'] * 1000))
def onMessage(self, payload, isBinary):
if isBinary:
logger.warning(
"Binary message received ({} bytes): ignoring".format(
len(payload)))
return
unicode_message = payload.decode('utf8', 'replace')
try:
message = json.loads(unicode_message)
except json.JSONDecodeError:
logger.exception(
"Cannot load {}: ignoring".format(unicode_message))
return
# message could be validated here with something like pydantic
logger.debug("{} >>> {}".format(self, message))
try:
if message["action"] == "publish":
self.factory.publish(message["event"], message["channel"])
elif message["action"] == "subscribe":
self.subscribe(message["channel"])
except Exception:
logger.error(
"Error while trying to process message={}: skipping".format(
message),
exc_info=True)
def cancel_release_task(self):
logger.debug('Cancelling release task')
try:
self.release_task.cancel()
except Exception as e:
logger.warning(
"Could not cancel release task (reason={})".format(e))
def loop_track(self):
time_before_loop = self.current_chapter[
'loop_b'] - self.current_chapter['loop_a']
self.schedule_looping_task(time_before_loop)
logger.debug('Setting player time to {}'.format(
self.current_chapter['loop_a']))
self.player.set_time(int(self.current_chapter['loop_a'] * 1000))
def new_player(self):
super(VLCDynamicSlidesPlayer, self).new_player()
logger.debug(
'Setting time={} because current slide is chapter id={}'.format(
self.current_chapter['start'],
self.slides[self.current_slide_index]))
# callLater because VLC seems to need some delay
reactor.callLater(0.01, self.player.set_time,
int(self.current_chapter['start'] * 1000))
def _cancel_table_tasks(self):
logger.debug("Cancelling table tasks")
if self.table_led_task and self.table_led_task.active():
logger.info("Cancelling table led task")
self.table_led_task.cancel()
if self.table_stop_motor_task and self.table_stop_motor_task.active():
logger.info("Cancelling table stop motor task")
self.table_stop_motor_task.cancel()
def check_lock_mistake(self):
reactor.callLater(self.unlock_frequency, self.check_lock_mistake)
logger.debug(
"Checking that locker is not locked (to prevent players from locking by mistake)"
)
if not self.locked and self.limit_switch.value:
logger.info(
"Locker was locked while it should not have been: unlocking")
self.event_unlock()
def set_chapter(self, chapter_id):
self.current_chapter_id = chapter_id
self.cancel_looping_task()
if self.player is not None:
logger.debug(
'Setting time={} because current chapter is {}'.format(
self.current_chapter['t_start'], self.current_chapter_id))
self.player.set_time(int(self.current_chapter['t_start'] * 1000))
if self.current_state == MediaPlayerMixin.STATE_PLAYING:
time_before_loop = self.current_chapter[
'loop_b'] - self.current_chapter['t_start']
self.schedule_looping_task(time_before_loop)
def pause(self):
if self.current_state == MediaPlayerMixin.STATE_NOT_STARTED:
logger.debug('Player has not been started yet')
logger.debug('Nothing to do')
elif self.current_state == MediaPlayerMixin.STATE_PLAYING:
logger.debug('Player is already playing')
self._pause()
self.current_state = MediaPlayerMixin.STATE_PAUSED
elif self.current_state == MediaPlayerMixin.STATE_PAUSED:
logger.debug('Player is paused and had already been started')
logger.debug('Nothing to do')
else:
pass
def next_slide(self):
self.current_slide_index = (self.current_slide_index + 1) % len(
self.slides)
time_before_slide = self.current_chapter['end'] - self.current_chapter[
'start']
self.schedule_slide_task(time_before_slide)
logger.debug(
'Setting player time to {} because current slide is chapter id={}'.
format(self.current_chapter['start'],
self.slides[self.current_slide_index]))
self.player.set_time(int(self.current_chapter['start']) * 1000)
self.service.notify_slide(self.current_slide_index)
def set_slide(self, slide_index, chapter_id):
self.current_slide_index = slide_index
self.slides[self.current_slide_index] = chapter_id
self.cancel_slide_task()
if self.player is not None:
logger.debug('Setting time={} because current slide is {}'.format(
self.current_chapter['start'],
self.slides[self.current_slide_index]))
self.player.set_time(int(self.current_chapter['start'] * 1000))
self.service.notify_slide(slide_index)
if self.current_state == MediaPlayerMixin.STATE_PLAYING:
time_before_slide = self.current_chapter[
'end'] - self.current_chapter['start']
self.schedule_slide_task(time_before_slide)
def __init__(self, media_path, chapters, *args, **kwargs):
super(VLCLoopingChapterVideoPlayer,
self).__init__(media_path, *args, **kwargs)
self.looping_task = None
default_chapter_id = chapters[0]['id']
logger.debug(
"Default chapter is chapter id={}".format(default_chapter_id))
chapter_dict = {}
for c in chapters:
id_ = c.pop('id')
chapter_dict[id_] = c
self.chapters = chapter_dict
self.current_chapter_id = None
self.set_chapter(default_chapter_id)
def status(self, value):
if value not in self.STATUSES:
logger.warning("Status not in {}: skipping".format(
value, ", ".join(self.STATUSES)))
return
if value == self.status:
logger.debug("Status is already {}: skipping".format(value))
return
logger.debug("Setting status to {}".format(value))
self._status = value
if self._status == "inactive":
self.on_inactive()
elif self._status == "playing":
self.on_playing()
self.service.notify_status(self.status)
def get_new_player(self):
logger.debug("Loading a new player")
return pexpect.spawn(self.omx_cmd)
def onOpen(self):
logger.debug("WebSocket connection opened")
self.factory.connection_opened()
def cancel_slide_task(self):
if self.slide_task and self.slide_task.active():
logger.debug('Cancelling slide task')
self.slide_task.cancel()
def onConnect(self, request):
logger.debug("Node connecting: {}".format(request.peer))
def _play(self):
logger.debug("Playing")
def schedule_slide_task(self, time):
logger.debug('Scheduling next slide in {} seconds'.format(time))
self.slide_task = reactor.callLater(time, self.next_slide)
def _resume(self):
logger.debug("Resuming")
def release_player(self):
logger.debug("Releasing player")
self.player.release()
self.player = None
def schedule_looping_task(self, time):
logger.debug('Scheduling track loop in {} seconds'.format(time))
self.looping_task = reactor.callLater(time, self.loop_track)
def _pause(self):
logger.debug("Pausing")
def _stop(self):
logger.debug("Stopping")
def new_player(self):
logger.debug("Loading a new player")
self.player = vlc.MediaPlayer()
self.player.set_fullscreen(True)
self.player.set_media(self.video)
def new_player(self):
logger.debug("Loading a new player")
self.player = vlc.MediaPlayer()
self.player.set_media(self.track)
self.set_volume()
def schedule_release_task(self, time):
logger.debug("Scheduling player release in {} seconds".format(time))
self.release_task = reactor.callLater(time, self.stop)
def startedConnecting(self, connector):
logger.debug('Started to connect')
