def load(self, text, loaded_callback, enable_menu):
# instantiate arguments
self.track = text
self.loaded_callback = loaded_callback # callback when loaded
self.mon.trace(self, '')
# do common bits of load
Player.pre_load(self)
# load the plugin, this may modify self.track and enable the plugin drawing to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
# can modify self.track with new text, does not touch message location
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# load the images and text including message text
status, message = self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
else:
self.play_state = 'loaded'
if self.loaded_callback is not None:
self.loaded_callback('loaded', 'message track loaded')
def load(self,track,loaded_callback,enable_menu):
# instantiate arguments
self.track=track # not used
self.loaded_callback=loaded_callback #callback when loaded
self.mon.trace(self,'')
# do common bits of load
Player.pre_load(self)
# bodge for menuplayer, pass medialist through track parameters
if 'medialist_obj' in self.show_params:
self.medialist=self.show_params['medialist_obj']
else:
self.mon.err(self,'A Menu Track must be run from a Menu Show')
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error','A Menu Track must be run from a Menu Show')
return
# load the images and text
status,message=Player.load_x_content(self,enable_menu)
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
else:
self.play_state='loaded'
if self.loaded_callback is not None:
self.loaded_callback('loaded','menu track loaded')
def load(self,text,loaded_callback,enable_menu):
# instantiate arguments
self.track=text
self.loaded_callback=loaded_callback # callback when loaded
self.mon.trace(self,'')
# do common bits of load
Player.pre_load(self)
# load the plugin, this may modify self.ttack and enable the plugin drawign to canvas
if self.track_params['plugin'] != '':
status,message=self.load_plugin()
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
# load the images and text including message text
status,message=self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
else:
self.play_state='loaded'
if self.loaded_callback is not None:
self.loaded_callback('loaded','message track loaded')
def load(self,track,loaded_callback,enable_menu):
# instantiate arguments
self.track=track # not used
self.loaded_callback=loaded_callback #callback when loaded
self.mon.trace(self,'')
# do common bits of load
Player.pre_load(self)
# bodge for menuplayer, pass medialist through track parameters
if 'medialist_obj' in self.show_params:
self.medialist=self.show_params['medialist_obj']
else:
self.mon.err(self,'A Menu Track must be run from a Menu Show')
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error','A Menu Track must be run from a Menu Show')
return
# load the images and text
status,message=Player.load_x_content(self,enable_menu)
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
else:
self.play_state='loaded'
if self.loaded_callback is not None:
self.loaded_callback('loaded','menu track loaded')
def load(self, track, loaded_callback, enable_menu):
# instantiate arguments
self.track = track
self.loaded_callback = loaded_callback #callback when loaded
# print '!!!!!!!!!!! videoplayer load',self.track
self.mon.log(
self, "Load track received from show Id: " + str(self.show_id) +
' ' + self.track)
self.mon.trace(self, '')
# do common bits of load
Player.pre_load(self)
# set up video window
status, message, command, has_window, x1, y1, x2, y2 = self.parse_video_window(
self.omx_window)
if status == 'error':
self.mon.err(
self,
'omx window error: ' + message + ' in ' + self.omx_window)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
else:
if has_window is True:
self.omx_window_processed = '--win " ' + str(x1) + ' ' + str(
y1) + ' ' + str(x2) + ' ' + str(y2) + ' " '
else:
self.omx_window_processed = ''
# load the plugin, this may modify self.track and enable the plugin drawign to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# load the images and text
status, message = self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
if not os.path.exists(track):
self.mon.err(self, "Track file not found: " + track)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'track file not found')
return
self.omx = OMXDriver(self.canvas, self.pp_dir)
self.start_state_machine_load(self.track)
def load(self,track,loaded_callback,enable_menu):
# instantiate arguments
self.track=track
self.loaded_callback=loaded_callback #callback when loaded
# print '!!!!!!!!!!! videoplayer load',self.track
self.mon.log(self,"Load track received from show Id: "+ str(self.show_id) + ' ' +self.track)
self.mon.trace(self,'')
# do common bits of load
Player.pre_load(self)
# set up video window
status,message,command,has_window,x1,y1,x2,y2= self.parse_video_window(self.omx_window)
if status == 'error':
self.mon.err(self,'omx window error: ' + message + ' in ' + self.omx_window)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
else:
if has_window is True:
self.omx_window_processed= '--win " '+ str(x1) + ' ' + str(y1) + ' ' + str(x2) + ' ' + str(y2) + ' " '
else:
self.omx_window_processed=''
# load the plugin, this may modify self.track and enable the plugin drawign to canvas
if self.track_params['plugin'] != '':
status,message=self.load_plugin()
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
# load the images and text
status,message=self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
if not os.path.exists(track):
self.mon.err(self,"Track file not found: "+ track)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error','track file not found')
return
self.omx=OMXDriver(self.canvas,self.pp_dir)
self.start_state_machine_load(self.track)
def load(self, track, loaded_callback, enable_menu):
# instantiate arguments
self.track = track
self.loaded_callback = loaded_callback #callback when loaded
self.mon.trace(self, '')
# do common bits of load
Player.pre_load(self)
# load the plugin, this may modify self.track and enable the plugin drawign to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# load the images and text
status, message = self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
if track != '' and self.duration_limit != 0 and not os.path.exists(
track):
self.mon.err(self, "Track file not found: " + track)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'track file not found: ' + track)
return
# just create instance of mplayer don't bother with any pre-load
self.mplayer = MplayerDriver(self.canvas, self.pp_dir)
self.play_state = 'loaded'
self.mon.log(self, "<Track loaded from show Id: " + str(self.show_id))
if self.loaded_callback is not None:
self.loaded_callback('loaded', 'audio track loaded')
def load(self, track, loaded_callback, enable_menu):
# instantiate arguments
self.track = track
# print 'imageplayer load',self.track
self.loaded_callback = loaded_callback # callback when loaded
self.mon.trace(self, '')
Player.pre_load(self)
# parse the image_window
status, message, self.command, self.has_coords, self.window_x1, self.window_y1, self.window_x2, self.window_y2, self.image_filter = self.parse_window(
self.image_window)
if status == 'error':
self.mon.err(
self,
'image window error, ' + message + ': ' + self.image_window)
self.play_state = 'load-failed'
self.loaded_callback(
'error',
'image window error, ' + message + ': ' + self.image_window)
return
# load the plugin, this may modify self.track and enable the plugin drawing to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
self.loaded_callback('error', message)
return
# load the images and text
status, message = Player.load_x_content(self, enable_menu)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
self.loaded_callback('error', message)
return
else:
self.play_state = 'loaded'
if self.loaded_callback is not None:
self.loaded_callback('loaded', 'image track loaded')
def load(self,track,loaded_callback,enable_menu):
# instantiate arguments
self.track=track
self.loaded_callback=loaded_callback #callback when loaded
self.mon.trace(self,'')
# do common bits of load
Player.pre_load(self)
# load the plugin, this may modify self.track and enable the plugin drawign to canvas
if self.track_params['plugin'] != '':
status,message=self.load_plugin()
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
# load the images and text
status,message=self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
if track !='' and self.duration_limit!=0 and not os.path.exists(track):
self.mon.err(self,"Track file not found: "+ track)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error','track file not found')
return
# just create instance of mplayer don't bother with any pre-load
self.mplayer=MplayerDriver(self.canvas,self.pp_dir)
self.play_state='loaded'
self.mon.log(self,"<Track loaded from show Id: "+ str(self.show_id))
if self.loaded_callback is not None:
self.loaded_callback('loaded','audio track loaded')
def load(self,track,loaded_callback,enable_menu):
# instantiate arguments
self.track=track
# print 'imageplayer load',self.track
self.loaded_callback=loaded_callback # callback when loaded
self.mon.trace(self,'')
Player.pre_load(self)
# parse the image_window
status,self.command,self.has_coords,self.window_x1,self.window_y1,self.window_x2,self.window_y2,self.image_filter=self.parse_window(self.image_window)
if status == 'error':
self.mon.err(self,'image window error: '+self.image_window)
self.play_state='load-failed'
self.loaded_callback('error','image window error: '+self.image_window)
return
# load the plugin, this may modify self.track and enable the plugin drawing to canvas
if self.track_params['plugin'] != '':
status,message=self.load_plugin()
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
self.loaded_callback('error',message)
return
# load the images and text
status,message=Player.load_x_content(self,enable_menu)
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
self.loaded_callback('error',message)
return
else:
self.play_state='loaded'
if self.loaded_callback is not None:
self.loaded_callback('loaded','image track loaded')
def load(self,track,loaded_callback,enable_menu):
# instantiate arguments
self.track=track
self.loaded_callback=loaded_callback #callback when loaded
self.mon.trace(self,'')
#for pulse get sink name and check device is connected
self.audio_sys=self.am.get_audio_sys()
if self.audio_sys == 'pulse':
status,message,self.mplayer_sink = self.am.get_sink(self.mplayer_audio)
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
if not self.am.sink_connected(self.mplayer_sink):
self.mon.err(self,'audio device not connected - '+self.mplayer_audio + '/n sink: '+self.mplayer_sink)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error','audio device not connected')
return
# do common bits of load
Player.pre_load(self)
# load the plugin, this may modify self.track and enable the plugin drawign to canvas
if self.track_params['plugin'] != '':
status,message=self.load_plugin()
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
# load the images and text
status,message=self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
if self.duration_text != '':
status,message,duration100=Player.parse_duration(self.duration_text)
if status =='error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error','track file not found: ' + track)
return
self.duration_limit= 2* duration100
else:
self.duration_limit=-1
#print (self.duration_limit)
if track !='' and self.duration_limit!=0 and not os.path.exists(track):
self.mon.err(self,"Track file not found: "+ track)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error','track file not found: ' + track)
return
# just create instance of mplayer don't bother with any pre-load
self.mplayer=MplayerDriver(self.canvas,self.pp_dir)
self.play_state='loaded'
self.mon.log(self,"<Track loaded from show Id: "+ str(self.show_id))
if self.loaded_callback is not None:
self.loaded_callback('loaded','audio track loaded')
def load(self, track, loaded_callback, enable_menu):
# instantiate arguments
self.track = track
self.loaded_callback = loaded_callback #callback when loaded
# print '!!!!!!!!!!! videoplayer load',self.track
self.mon.log(
self, "Load track received from show Id: " + str(self.show_id) +
' ' + self.track)
self.mon.trace(self, '')
# do common bits of load
Player.pre_load(self)
# set up video display
if self.track_params['display-name'] != "":
video_display_name = self.track_params['display-name']
else:
video_display_name = self.show_canvas_display_name
status, message, self.omx_display_id = self.dm.id_of_display(
video_display_name)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback(
'error', 'Display not connected: ' + video_display_name)
return
# set up video window and calc orientation
status, message, command, has_window, x1, y1, x2, y2 = self.parse_video_window(
self.omx_window, self.omx_display_id)
if status == 'error':
self.mon.err(
self,
'omx window error: ' + message + ' in ' + self.omx_window)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback(
'error',
'omx window error: ' + message + ' in ' + self.omx_window)
return
else:
if has_window is True:
self.omx_window_processed = '--win " ' + str(x1) + ' ' + str(
y1) + ' ' + str(x2) + ' ' + str(y2) + ' " '
else:
self.omx_window_processed = self.omx_aspect_mode
# load the plugin, this may modify self.track and enable the plugin drawign to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# load the images and text
status, message = self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
if not (track[0:3] in ('udp', 'tcp')
or track[0:4] in ('rtsp', 'rtmp')):
if not os.path.exists(track):
self.mon.err(self, "Track file not found: " + track)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',
'track file not found: ' + track)
return
self.omx = OMXDriver(self.canvas, self.pp_dir)
self.start_state_machine_load(self.track)
def load(self, track, loaded_callback, enable_menu):
# instantiate arguments
self.track = track
self.loaded_callback = loaded_callback # callback when loaded
self.mon.trace(self, '')
# do common bits of load
Player.pre_load(self)
#parse web window
reason, message, command, has_window, x1, y1, x2, y2 = self.parse_window(
self.web_window)
if reason == 'error':
self.mon.err(
self, 'web window error: ' + ' ' + message + ' in ' +
self.web_window)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# compute web_window size
if has_window is False:
self.geometry = ' --geometry=maximized '
else:
width = x2 - x1
height = y2 - y1
self.geometry = "--geometry=%dx%d%+d%+d " % (width, height, x1, y1)
# parse browser commands to self.command_list
reason, message = self.parse_commands(
self.track_params['browser-commands'])
if reason == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# load the plugin, this may modify self.track and enable the plugin drawing to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# start loading the browser
self.play_state = 'loading'
self.bplayer.play(self.track, self.geometry)
self.mon.log(self,
'Loading browser from show Id: ' + str(self.show_id))
# load the images and text
status, message = self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# wait for browser to load
self.start_load_state_machine()
def load(self,track,loaded_callback,enable_menu):
# instantiate arguments
self.track=track
self.loaded_callback=loaded_callback # callback when loaded
self.mon.trace(self,'')
# do common bits of load
Player.pre_load(self)
#parse web window
reason,message,command,has_window,x1,y1,x2,y2=self.parse_window(self.web_window)
if reason == 'error':
self.mon.err(self,'web window error: '+' ' + message + ' in ' + self.web_window)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
# compute web_window size
if has_window is False:
self.geometry = ' --geometry=maximized '
else:
width=x2-x1
height=y2-y1
self.geometry = "--geometry=%dx%d%+d%+d " % (width,height,x1,y1)
# parse browser commands to self.command_list
reason,message=self.parse_commands(self.track_params['browser-commands'])
if reason == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
# load the plugin, this may modify self.track and enable the plugin drawing to canvas
if self.track_params['plugin'] != '':
status,message=self.load_plugin()
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
# start loading the browser
self.play_state='loading'
self.bplayer.play(self.track,self.geometry)
self.mon.log (self,'Loading browser from show Id: '+ str(self.show_id))
# load the images and text
status,message=self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self,message)
self.play_state='load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',message)
return
# wait for browser to load
self.start_load_state_machine()
def load(self, track, loaded_callback, enable_menu):
# instantiate arguments
self.track = track
self.loaded_callback = loaded_callback #callback when loaded
self.mon.log(
self, "Load track received from show Id: " + str(self.show_id) +
' ' + self.track)
self.mon.trace(self, '')
#process vlc parameters
status, message = self.process_params()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
#for pulse get sink name and check device is connected
self.audio_sys = self.am.get_audio_sys()
if self.audio_sys == 'pulse':
status, message, self.vlc_sink = self.am.get_sink(self.vlc_audio)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
if not self.am.sink_connected(self.vlc_sink):
self.mon.err(
self, self.vlc_audio +
' audio device not connected\n\n sink: ' +
self.vlc_sink)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'audio device not connected')
return
else:
self.mon.err(
self,
'audio systems other than pulseaudio are not supported\n hint: audio.cfg error'
)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'audio device not connected')
return
# do common bits of load
Player.pre_load(self)
# load the plugin, this may modify self.track and enable the plugin drawing to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# load the images and text
status, message = self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# check file exists if not a mrl
if not ':' in track:
if not os.path.exists(track):
self.mon.err(self, "Track file not found: " + track)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',
'track file not found: ' + track)
return
cmd = 'DISPLAY= python3 ' + self.pp_dir + '/pp_vlcdriver.py'
#print (cmd)
# need bash because of DISPLAY=
self.vlcdriver = pexpect.spawn('/bin/bash', ['-c', cmd],
encoding='utf-8')
# get rid of driver start message
start_message = self.vlcdriver.readline().strip('\r\n')
if start_message != 'VLCDriver starting':
self.mon.fatal(
self, "VLCDriver failed\n Hint: sudo pip3 install python-vlc ")
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'VLCDriver starting')
return
self.vlcdriver.setecho(False)
self.vlcdriver.sendline('iopts' + self.iopts)
self.vlcdriver.sendline('pauseopts' + self.pauseopts)
self.vlcdriver.sendline('track ' + track)
# load the media
self.vlcdriver.sendline('load')
#get size of media, do after load and before play. Not used at the moment
self.media_width, self.media_height = self.get_size()
# calculate and send crop/aspect ratio and aspect mode. Done here as size might be needed in the future
status, message = self.aspect_mode()
if status != 'normal':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'track file not found: ' + track)
return
# play until pause at start
self.vlcdriver.sendline('play')
self.start_state_machine_load()
def load(self, track, loaded_callback, enable_menu):
# instantiate arguments
self.loaded_callback = loaded_callback # callback when loaded
self.mon.trace(self, '')
status, message, duration100 = Player.parse_duration(
self.duration_text)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
self.duration = 2 * duration100
# Is display valid and connected
status, message, self.display_id = self.dm.id_of_display(
self.show_canvas_display_name)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'cannot find file; ' + track)
return
# does media exist
if not ':' in track:
if not os.path.exists(track):
self.mon.err(self, 'cannot find file; ' + track)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'cannot find file; ' + track)
return
# add file:// to files.
if ':' in track:
self.current_url = track
else:
self.current_url = 'file://' + track
# do common bits of load
Player.pre_load(self)
# prepare chromium options
status, message = self.process_chrome_options()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# parse browser commands to self.command_list
reason, message = self.parse_commands(
self.track_params['browser-commands'])
if reason == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# load the plugin, this may modify self.track and enable the plugin drawing to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# start loading the browser
self.play_state = 'loading'
# load the images and text
status, message = self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
#start the browser
self.driver_open()
# for kiosk and fullscreen need to get the url - in browser command for app mode
if self.app_mode is False:
self.driver_get(self.current_url)
self.mon.log(self,
'Loading browser from show Id: ' + str(self.show_id))
self.play_state = 'loaded'
# and start executing the browser commands
self.play_commands()
self.mon.log(self, " State machine: chromium loaded")
if self.loaded_callback is not None:
self.loaded_callback('normal', 'browser loaded')
return
