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')