def __init__(self, show_id, show_params, root, canvas, showlist, pp_dir, pp_home, pp_profile, command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(
self, show_id, show_params, root, canvas, showlist, pp_dir, pp_home, pp_profile, command_callback
)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr = ScreenDriver()
self.controlsmanager = ControlsManager()
# init variables
self.show_timeout_timer = None
self.track_timeout_timer = None
self.next_track_signal = False
self.next_track = None
self.menu_index = 0
self.menu_showing = True
self.req_next = ""
def __init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr=ScreenDriver()
# create a path stack and control path debugging
if self.show_params['debug-path']=='yes':
self.debug=True
else:
self.debug=False
self.path = PathManager()
self.allowed_links=('return','home','call','null','exit','goto','play','jump','repeat','pause','no-command','stop','pause-on','pause-off','mute','unmute','go')
# init variables
self.track_timeout_timer=None
self.show_timeout_timer=None
self.next_track_signal=False
self.next_track_ref=''
self.current_track_ref=''
self.current_track_type=''
self.req_next=''
def __init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback):
# init the common bits
Show.base__init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr=ScreenDriver()
self.controlsmanager=ControlsManager()
# Init variables special to this show
self.poll_for_interval_timer=None
self.interval_timer_signal=False
self.waiting_for_interval=False
self.interval_timer=None
self.duration_timer=None
self.end_trigger_signal=False
self.next_track_signal=False
self.previous_track_signal=False
self.play_child_signal = False
self.error_signal=False
self.show_timeout_signal=False
self.req_next='nil'
self.state='closed'
self.count=0
self.interval=0
self.duration=0
self.controls_list=[]
self.enable_hint= True
self.escapetrack_required=False
def __init__(self, show_id, show_params, root, canvas, showlist, pp_dir, pp_home, pp_profile, command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(
self, show_id, show_params, root, canvas, showlist, pp_dir, pp_home, pp_profile, command_callback
)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr = ScreenDriver()
# create a path stack and control path debugging
if self.show_params["debug-path"] == "yes":
self.debug = True
else:
self.debug = False
self.path = PathManager()
self.allowed_links = (
"return",
"home",
"call",
"null",
"exit",
"goto",
"play",
"jump",
"repeat",
"pause",
"no-command",
"stop",
)
# init variables
self.track_timeout_timer = None
self.show_timeout_timer = None
self.next_track_signal = False
self.next_track_ref = ""
self.current_track_ref = ""
self.current_track_type = ""
self.req_next = ""
def __init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr=ScreenDriver()
# create an instance of PathManager - only used to parse the links.
self.path = PathManager()
self.allowed_links=('play','pause','exit','return','null','no-command','stop')
# init variables
self.links=[]
self.track_timeout_timer=None
self.show_timeout_timer=None
self.next_track_signal=False
self.current_track_ref=''
self.req_next=''
def __init__(self):
gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
self.pipresents_issue="1.3"
self.pipresents_minorissue = '1.3.1g'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height= 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
self.pp_background='black'
StopWatch.global_enable=False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM,self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get Pi Presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
if self.options['manager'] is False:
tkMessageBox.showwarning("Pi Presents","Bad Application Directory:\n{0}".format(pp_dir))
exit(103)
# Initialise logging and tracing
Monitor.log_path=pp_dir
self.mon=Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = ['PiPresents', 'pp_paths',
'HyperlinkShow','RadioButtonShow','ArtLiveShow','ArtMediaShow','MediaShow','LiveShow','MenuShow',
'PathManager','ControlsManager','ShowManager','PluginManager',
'MplayerDriver','OMXDriver','UZBLDriver',
'KbdDriver','GPIODriver','TimeOfDay','ScreenDriver','Animate','OSCDriver'
]
# Monitor.classes=['PiPresents','ArtMediaShow','VideoPlayer','OMXDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.log (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue)
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
if os.geteuid() !=0:
user=os.getenv('USER')
else:
user = os.getenv('SUDO_USER')
self.mon.log(self,'User is: '+ user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# optional other classes used
self.root=None
self.ppio=None
self.tod=None
self.animate=None
self.gpiodriver=None
self.oscdriver=None
self.osc_enabled=False
self.gpio_enabled=False
self.tod_enabled=False
# get home path from -o option
self.pp_home = pp_paths.get_home(self.options['home'])
if self.pp_home is None:
self.end('error','Failed to find pp_home')
# get profile path from -p option
# pp_profile is the full path to the directory that contains
# pp_showlist.json and other files for the profile
self.pp_profile = pp_paths.get_profile_dir(self.pp_home, self.options['profile'])
if self.pp_profile is None:
self.end('error','Failed to find profile')
# check profile exists
if os.path.exists(self.pp_profile):
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.mon.err(self,"Failed to find requested profile: "+ self.pp_profile)
self.end('error','Failed to find profile')
self.mon.start_stats(self.options['profile'])
# check 'verify' option
if self.options['verify'] is True:
val =Validator()
if val.validate_profile(None,pp_dir,self.pp_home,self.pp_profile,self.pipresents_issue,False) is False:
self.mon.err(self,"Validation Failed")
self.end('error','Validation Failed')
# initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error','showlist not found')
# check profile and Pi Presents issues are compatible
if float(self.showlist.sissue()) != float(self.pipresents_issue):
self.mon.err(self,"Version of profile " + self.showlist.sissue() + " is not same as Pi Presents, must exit")
self.end('error','wrong version of profile')
# get the 'start' show from the showlist
index = self.showlist.index_of_show('start')
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error','start show not found')
if self.starter_show['start-show']=='':
self.mon.warn(self,"No Start Shows in Start Show")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg=self.pp_background)
self.mon.log(self, 'native screen dimensions are ' + str(self.root.winfo_screenwidth()) + ' x ' + str(self.root.winfo_screenheight()) + ' pixcels')
if self.options['screensize'] =='':
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
else:
reason,message,self.screen_width,self.screen_height=self.parse_screen(self.options['screensize'])
if reason =='error':
self.mon.err(self,message)
self.end('error',message)
self.mon.log(self, 'commanded screen dimensions are ' + str(self.screen_width) + ' x ' + str(self.screen_height) + ' pixcels')
# set window dimensions and decorations
if self.options['fullscreen'] is False:
self.window_width=int(self.root.winfo_screenwidth()*self.nonfull_window_width)
self.window_height=int(self.root.winfo_screenheight()*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
else:
self.window_width=self.screen_width
self.window_height=self.screen_height
self.root.attributes('-fullscreen', True)
os.system('unclutter 1>&- 2>&- &') # Suppress 'someone created a subwindow' complaints from unclutter
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
# canvs cover the whole screen whatever the size of the window.
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
# define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.handle_user_abort)
# setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg=self.pp_background)
if self.options['fullscreen'] is True:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
else:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=1,
highlightcolor='yellow')
self.canvas.place(x=0,y=0)
# self.canvas.config(bg='black')
self.canvas.focus_set()
# ****************************************
# INITIALISE THE INPUT DRIVERS
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs/
# use keyboard driver to bind keys to symbolic names and to set up callback
kbd=KbdDriver()
if kbd.read(pp_dir,self.pp_home,self.pp_profile) is False:
self.end('error','cannot find or error in keys.cfg')
kbd.bind_keys(self.root,self.handle_input_event)
self.sr=ScreenDriver()
# read the screen click area config file
reason,message = self.sr.read(pp_dir,self.pp_home,self.pp_profile)
if reason == 'error':
self.end('error','cannot find screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
# click areas are made on the Pi Presents canvas not the show canvases.
reason,message = self.sr.make_click_areas(self.canvas,self.handle_input_event)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
self.exitpipresents_required=False
# kick off GPIO if enabled by command line option
self.gpio_enabled=False
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+os.sep+ 'gpio.cfg'):
# initialise the GPIO
self.gpiodriver=GPIODriver()
reason,message=self.gpiodriver.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,50,self.handle_input_event)
if reason == 'error':
self.end('error',message)
else:
self.gpio_enabled=True
# and start polling gpio
self.gpiodriver.poll()
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,200,self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id=-1
self.show_manager=ShowManager(show_id,self.showlist,self.starter_show,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.canvas,self.all_shows_ended_callback,self.handle_command,self.showlist)
# Register all the shows in the showlist
reason,message=self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled=False
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+ os.sep + 'osc.cfg'):
self.oscdriver=OSCDriver()
reason,message=self.oscdriver.init(self.pp_profile,self.handle_command,self.handle_input_event,self.e_osc_handle_output_event)
if reason == 'error':
self.end('error',message)
else:
self.osc_enabled=True
self.root.after(1000,self.oscdriver.start_server())
# and run the start shows
self.run_start_shows()
# set up the time of day scheduler including catchup
self.tod_enabled=False
if os.path.exists(self.pp_profile + os.sep + 'schedule.json'):
# kick off the time of day scheduler which may run additional shows
self.tod=TimeOfDay()
self.tod.init(pp_dir,self.pp_home,self.pp_profile,self.root,self.handle_command)
self.tod_enabled = True
# then start the time of day scheduler
if self.tod_enabled is True:
self.tod.poll()
# start Tkinters event loop
self.root.mainloop( )
class PiPresents(object):
def __init__(self):
gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
self.pipresents_issue="1.3"
self.pipresents_minorissue = '1.3.1g'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height= 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
self.pp_background='black'
StopWatch.global_enable=False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM,self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get Pi Presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
if self.options['manager'] is False:
tkMessageBox.showwarning("Pi Presents","Bad Application Directory:\n{0}".format(pp_dir))
exit(103)
# Initialise logging and tracing
Monitor.log_path=pp_dir
self.mon=Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = ['PiPresents', 'pp_paths',
'HyperlinkShow','RadioButtonShow','ArtLiveShow','ArtMediaShow','MediaShow','LiveShow','MenuShow',
'PathManager','ControlsManager','ShowManager','PluginManager',
'MplayerDriver','OMXDriver','UZBLDriver',
'KbdDriver','GPIODriver','TimeOfDay','ScreenDriver','Animate','OSCDriver'
]
# Monitor.classes=['PiPresents','ArtMediaShow','VideoPlayer','OMXDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.log (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue)
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
if os.geteuid() !=0:
user=os.getenv('USER')
else:
user = os.getenv('SUDO_USER')
self.mon.log(self,'User is: '+ user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# optional other classes used
self.root=None
self.ppio=None
self.tod=None
self.animate=None
self.gpiodriver=None
self.oscdriver=None
self.osc_enabled=False
self.gpio_enabled=False
self.tod_enabled=False
# get home path from -o option
self.pp_home = pp_paths.get_home(self.options['home'])
if self.pp_home is None:
self.end('error','Failed to find pp_home')
# get profile path from -p option
# pp_profile is the full path to the directory that contains
# pp_showlist.json and other files for the profile
self.pp_profile = pp_paths.get_profile_dir(self.pp_home, self.options['profile'])
if self.pp_profile is None:
self.end('error','Failed to find profile')
# check profile exists
if os.path.exists(self.pp_profile):
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.mon.err(self,"Failed to find requested profile: "+ self.pp_profile)
self.end('error','Failed to find profile')
self.mon.start_stats(self.options['profile'])
# check 'verify' option
if self.options['verify'] is True:
val =Validator()
if val.validate_profile(None,pp_dir,self.pp_home,self.pp_profile,self.pipresents_issue,False) is False:
self.mon.err(self,"Validation Failed")
self.end('error','Validation Failed')
# initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error','showlist not found')
# check profile and Pi Presents issues are compatible
if float(self.showlist.sissue()) != float(self.pipresents_issue):
self.mon.err(self,"Version of profile " + self.showlist.sissue() + " is not same as Pi Presents, must exit")
self.end('error','wrong version of profile')
# get the 'start' show from the showlist
index = self.showlist.index_of_show('start')
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error','start show not found')
if self.starter_show['start-show']=='':
self.mon.warn(self,"No Start Shows in Start Show")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg=self.pp_background)
self.mon.log(self, 'native screen dimensions are ' + str(self.root.winfo_screenwidth()) + ' x ' + str(self.root.winfo_screenheight()) + ' pixcels')
if self.options['screensize'] =='':
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
else:
reason,message,self.screen_width,self.screen_height=self.parse_screen(self.options['screensize'])
if reason =='error':
self.mon.err(self,message)
self.end('error',message)
self.mon.log(self, 'commanded screen dimensions are ' + str(self.screen_width) + ' x ' + str(self.screen_height) + ' pixcels')
# set window dimensions and decorations
if self.options['fullscreen'] is False:
self.window_width=int(self.root.winfo_screenwidth()*self.nonfull_window_width)
self.window_height=int(self.root.winfo_screenheight()*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
else:
self.window_width=self.screen_width
self.window_height=self.screen_height
self.root.attributes('-fullscreen', True)
os.system('unclutter 1>&- 2>&- &') # Suppress 'someone created a subwindow' complaints from unclutter
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
# canvs cover the whole screen whatever the size of the window.
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
# define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.handle_user_abort)
# setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg=self.pp_background)
if self.options['fullscreen'] is True:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
else:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=1,
highlightcolor='yellow')
self.canvas.place(x=0,y=0)
# self.canvas.config(bg='black')
self.canvas.focus_set()
# ****************************************
# INITIALISE THE INPUT DRIVERS
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs/
# use keyboard driver to bind keys to symbolic names and to set up callback
kbd=KbdDriver()
if kbd.read(pp_dir,self.pp_home,self.pp_profile) is False:
self.end('error','cannot find or error in keys.cfg')
kbd.bind_keys(self.root,self.handle_input_event)
self.sr=ScreenDriver()
# read the screen click area config file
reason,message = self.sr.read(pp_dir,self.pp_home,self.pp_profile)
if reason == 'error':
self.end('error','cannot find screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
# click areas are made on the Pi Presents canvas not the show canvases.
reason,message = self.sr.make_click_areas(self.canvas,self.handle_input_event)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
self.exitpipresents_required=False
# kick off GPIO if enabled by command line option
self.gpio_enabled=False
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+os.sep+ 'gpio.cfg'):
# initialise the GPIO
self.gpiodriver=GPIODriver()
reason,message=self.gpiodriver.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,50,self.handle_input_event)
if reason == 'error':
self.end('error',message)
else:
self.gpio_enabled=True
# and start polling gpio
self.gpiodriver.poll()
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,200,self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id=-1
self.show_manager=ShowManager(show_id,self.showlist,self.starter_show,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.canvas,self.all_shows_ended_callback,self.handle_command,self.showlist)
# Register all the shows in the showlist
reason,message=self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled=False
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+ os.sep + 'osc.cfg'):
self.oscdriver=OSCDriver()
reason,message=self.oscdriver.init(self.pp_profile,self.handle_command,self.handle_input_event,self.e_osc_handle_output_event)
if reason == 'error':
self.end('error',message)
else:
self.osc_enabled=True
self.root.after(1000,self.oscdriver.start_server())
# and run the start shows
self.run_start_shows()
# set up the time of day scheduler including catchup
self.tod_enabled=False
if os.path.exists(self.pp_profile + os.sep + 'schedule.json'):
# kick off the time of day scheduler which may run additional shows
self.tod=TimeOfDay()
self.tod.init(pp_dir,self.pp_home,self.pp_profile,self.root,self.handle_command)
self.tod_enabled = True
# then start the time of day scheduler
if self.tod_enabled is True:
self.tod.poll()
# start Tkinters event loop
self.root.mainloop( )
def parse_screen(self,size_text):
fields=size_text.split('*')
if len(fields)!=2:
return 'error','do not understand --fullscreen comand option',0,0
elif fields[0].isdigit() is False or fields[1].isdigit() is False:
return 'error','dimensions are not positive integers in ---fullscreen',0,0
else:
return 'normal','',int(fields[0]),int(fields[1])
# *********************
# RUN START SHOWS
# ********************
def run_start_shows(self):
self.mon.trace(self,'run start shows')
# parse the start shows field and start the initial shows
show_refs=self.starter_show['start-show'].split()
for show_ref in show_refs:
reason,message=self.show_manager.control_a_show(show_ref,'open')
if reason == 'error':
self.mon.err(self,message)
# *********************
# User inputs
# ********************
# handles one command provided as a line of text
def handle_command(self,command_text):
self.mon.log(self,"command received: " + command_text)
if command_text.strip()=="":
return
if command_text[0]=='/':
if self.osc_enabled is True:
self.oscdriver.send_command(command_text)
return
fields= command_text.split()
show_command=fields[0]
if len(fields)>1:
show_ref=fields[1]
else:
show_ref=''
if show_command in ('open','close'):
if self.shutdown_required is False:
reason,message=self.show_manager.control_a_show(show_ref,show_command)
else:
return
elif show_command == 'exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to get out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
else:
reason,message= self.show_manager.exit_all_shows()
elif show_command == 'shutdownnow':
# need root.after to get out of st thread
self.root.after(1,self.e_shutdown_pressed)
return
else:
reason='error'
message = 'command not recognised: '+ show_command
if reason=='error':
self.mon.err(self,message)
return
def e_all_shows_ended_callback(self):
self.all_shows_ended_callback('normal','no shows running')
def e_shutdown_pressed(self):
self.shutdown_pressed('now')
def e_osc_handle_output_event(self,line):
#jump out of server thread
self.root.after(1, lambda arg=line: self.osc_handle_output_event(arg))
def osc_handle_output_event(self,line):
self.mon.log(self,"output event received: "+ line)
#osc sends output events as a string
reason,message,delay,name,param_type,param_values=self.animate.parse_animate_fields(line)
if reason == 'error':
self.mon.err(self,message)
self.end(reason,message)
self.handle_output_event(name,param_type,param_values,0)
def handle_output_event(self,symbol,param_type,param_values,req_time):
if self.gpio_enabled is True:
reason,message=self.gpiodriver.handle_output_event(symbol,param_type,param_values,req_time)
if reason =='error':
self.mon.err(self,message)
self.end(reason,message)
else:
self.mon.warn(self,'GPIO not enabled')
# all input events call this callback with a symbolic name.
# handle events that affect PP overall, otherwise pass to all active shows
def handle_input_event(self,symbol,source):
self.mon.log(self,"event received: "+symbol + ' from '+ source)
if symbol == 'pp-terminate':
self.handle_user_abort()
elif symbol == 'pp-shutdown':
self.shutdown_pressed('delay')
elif symbol == 'pp-shutdownnow':
# need root.after to grt out of st thread
self.root.after(1,self.e_shutdown_pressed)
return
elif symbol == 'pp-exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to grt out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
reason,message= self.show_manager.exit_all_shows()
else:
# events for shows affect the show and could cause it to exit.
for show in self.show_manager.shows:
show_obj=show[ShowManager.SHOW_OBJ]
if show_obj is not None:
show_obj.handle_input_event(symbol)
def shutdown_pressed(self, when):
if when == 'delay':
self.root.after(5000,self.on_shutdown_delay)
else:
self.shutdown_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def on_shutdown_delay(self):
# 5 second delay is up, if shutdown button still pressed then shutdown
if self.gpiodriver.shutdown_pressed() is True:
self.shutdown_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def handle_sigterm(self,signum,frame):
self.mon.log(self,'SIGTERM received - '+ str(signum))
self.terminate()
def handle_user_abort(self):
self.mon.log(self,'User abort received')
self.terminate()
def terminate(self):
self.mon.log(self, "terminate received")
needs_termination=False
for show in self.show_manager.shows:
# print show[ShowManager.SHOW_OBJ], show[ShowManager.SHOW_REF]
if show[ShowManager.SHOW_OBJ] is not None:
needs_termination=True
self.mon.log(self,"Sent terminate to show "+ show[ShowManager.SHOW_REF])
# call shows terminate method
# eventually the show will exit and after all shows have exited all_shows_callback will be executed.
show[ShowManager.SHOW_OBJ].terminate()
if needs_termination is False:
self.end('killed','killed - no termination of shows required')
# ******************************
# Ending Pi Presents after all the showers and players are closed
# **************************
# callback from ShowManager when all shows have ended
def all_shows_ended_callback(self,reason,message):
self.canvas.config(bg=self.pp_background)
if reason in ('killed','error') or self.shutdown_required is True or self.exitpipresents_required is True:
self.end(reason,message)
def end(self,reason,message):
self.mon.log(self,"Pi Presents ending with reason: " + reason)
if self.root is not None:
self.root.destroy()
self.tidy_up()
# gc.collect()
# print gc.garbage
if reason == 'killed':
self.mon.log(self, "Pi Presents Aborted, au revoir")
# close logging files
self.mon.finish()
sys.exit(101)
elif reason == 'error':
self.mon.log(self, "Pi Presents closing because of error, sorry")
# close logging files
self.mon.finish()
sys.exit(102)
else:
self.mon.log(self,"Pi Presents exiting normally, bye")
# close logging files
self.mon.finish()
if self.shutdown_required is True:
# print 'SHUTDOWN'
call(['sudo', 'shutdown', '-h', '-t 5','now'])
sys.exit(100)
else:
sys.exit(100)
# tidy up all the peripheral bits of Pi Presents
def tidy_up(self):
self.mon.log(self, "Tidying Up")
# turn screen blanking back on
if self.options['noblank'] is True:
call(["xset","s", "on"])
call(["xset","s", "+dpms"])
# tidy up animation and gpio
if self.animate is not None:
self.animate.terminate()
if self.gpio_enabled==True:
self.gpiodriver.terminate()
if self.osc_enabled is True:
self.oscdriver.terminate()
# tidy up time of day scheduler
if self.tod_enabled is True:
self.tod.terminate()
class MenuShow(Show):
def __init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr=ScreenDriver()
self.controlsmanager=ControlsManager()
# init variables
self.show_timeout_timer=None
self.track_timeout_timer=None
self.next_track_signal=False
self.next_track=None
self.menu_index=0
self.menu_showing=True
self.req_next=''
def play(self,end_callback,show_ready_callback,parent_kickback_signal,level,controls_list):
""" displays the menu
end_callback - function to be called when the menu exits
show_ready_callback - callback when menu is ready to display (not used)
level is 0 when the show is top level (run from [start] or from show control)
parent_kickback_signal - not used other than it being passed to a show
"""
# need to instantiate the medialist here as not using gapshow
self.medialist=MediaList('ordered')
Show.base_play(self,end_callback,show_ready_callback, parent_kickback_signal,level,controls_list)
self.mon.trace(self,self.show_params['show-ref'])
#parse the show and track timeouts
reason,message,self.show_timeout=Show.calculate_duration(self,self.show_params['show-timeout'])
if reason =='error':
self.mon.err(self,'Show Timeout has bad time: '+self.show_params['show-timeout'])
self.end('error','show timeout, bad time')
reason,message,self.track_timeout=Show.calculate_duration(self,self.show_params['track-timeout'])
if reason=='error':
self.mon.err(self,'Track Timeout has bad time: '+self.show_params['track-timeout'])
self.end('error','track timeout, bad time')
# and delete eggtimer
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
# and display the menu
self.do_menu_track()
# ********************
# respond to inputs.
# ********************
# exit received from another concurrent show
def exit(self):
self.stop_timers()
Show.base_exit(self)
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
# terminate Pi Presents
def terminate(self):
self.stop_timers()
Show.base_terminate(self)
def handle_input_event(self,symbol):
Show.base_handle_input_event(self,symbol)
def handle_input_event_this_show(self,symbol):
# menushow has only internal operation
operation=self.base_lookup_control(symbol,self.controls_list)
self.do_operation(operation)
def do_operation(self,operation):
# service the standard inputs for this show
self.mon.trace(self,operation)
if operation =='exit':
self.exit()
elif operation == 'stop':
self.stop_timers()
if self.current_player is not None:
if self.menu_showing is True and self.level != 0:
# if quiescent then set signal to stop the show when track has stopped
self.user_stop_signal=True
self.current_player.input_pressed('stop')
elif operation in ('up','down'):
# stop show timeout
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
# and start it again
if self.show_timeout != 0:
self.show_timeout_timer=self.canvas.after(self.show_timeout*1000,self.show_timeout_stop)
if operation=='up':
self.previous()
else:
self.next()
elif operation =='play':
self.next_track_signal=True
self.next_track=self.medialist.selected_track()
self.current_player.stop()
# cancel show timeout
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
# stop current track (the menuplayer) if running or just start the next track
if self.current_player is not None:
self.current_player.input_pressed('stop')
else:
self.what_next_after_showing()
elif operation in ('no-command','null'):
return
elif operation == 'pause':
if self.current_player is not None:
self.current_player.input_pressed(operation)
elif operation[0:4]=='omx-' or operation[0:6]=='mplay-'or operation[0:5]=='uzbl-':
if self.current_player is not None:
self.current_player.input_pressed(operation)
def next(self):
# remove highlight
if self.current_player.__class__.__name__ == 'MenuPlayer':
self.current_player.highlight_menu_entry(self.menu_index,False)
self.medialist.next('ordered')
if self.menu_index==self.menu_length-1:
self.menu_index=0
else:
self.menu_index+=1
# and highlight the new entry
self.current_player.highlight_menu_entry(self.menu_index,True)
def previous(self):
# remove highlight
if self.current_player.__class__.__name__ == 'MenuPlayer':
self.current_player.highlight_menu_entry(self.menu_index,False)
if self.menu_index==0:
self.menu_index=self.menu_length-1
else:
self.menu_index-=1
self.medialist.previous('ordered')
# and highlight the new entry
self.current_player.highlight_menu_entry(self.menu_index,True)
# *********************
# Sequencing
# *********************
def track_timeout_callback(self):
self.do_operation('stop')
def do_menu_track(self):
self.menu_showing=True
self.mon.trace(self,'')
# start show timeout alarm if required
if self.show_timeout != 0:
self.show_timeout_timer=self.canvas.after(self.show_timeout *1000,self.show_timeout_stop)
# init the index used to hiighlight the selected menu entry by menuplayer
self.menu_index=0
index = self.medialist.index_of_track(self.show_params['menu-track-ref'])
if index == -1:
self.mon.err(self,"'menu-track' not in medialist: " + self.show_params['menu-track-ref'])
self.end('error',"menu-track not in medialist: ")
return
#make the medialist available to the menuplayer for cursor scrolling
self.show_params['medialist_obj']=self.medialist
# load the menu track
self.start_load_show_loop(self.medialist.track(index))
# *********************
# Playing show or track loop
# *********************
def start_load_show_loop(self,selected_track):
# shuffle players
Show.base_shuffle(self)
self.mon.trace(self,'')
self.display_eggtimer()
# get control bindings for this show
# needs to be done for each track as track can override the show controls
if self.show_params['disable-controls'] == 'yes':
self.controls_list=[]
else:
reason,message,self.controls_list= self.controlsmanager.get_controls(self.show_params['controls'])
if reason=='error':
self.mon.err(self,message)
self.end('error',"error in controls")
return
# load the track or show
Show.base_load_track_or_show(self,selected_track,self.what_next_after_load,self.end_shower,False)
# track has loaded (menu or otherwise) so show it.
def what_next_after_load(self,status,message):
# get the calculated length of the menu for the loaded menu track
if self.current_player.__class__.__name__ == 'MenuPlayer':
if self.medialist.display_length()==0:
self.req_next='error'
self.what_next_after_showing()
return
self.medialist.start()
self.menu_index=0
self.menu_length=self.current_player.menu_length
self.current_player.highlight_menu_entry(self.menu_index,True)
self.mon.trace(self,' - load complete with status: ' + status + ' message: ' + message)
if self.current_player.play_state=='load-failed':
self.req_next='error'
self.what_next_after_showing()
else:
if self.show_timeout_signal is True or self.terminate_signal is True or self.exit_signal is True or self.user_stop_signal is True:
self.what_next_after_showing()
else:
self.mon.trace(self,'')
self.current_player.show(self.track_ready_callback,self.finished_showing,self.closed_after_showing)
def finished_showing(self,reason,message):
# showing has finished with 'pause at end', showing the next track will close it after next has started showing
self.mon.trace(self,'')
self.mon.log(self,"pause at end of showing track with reason: "+reason+ ' and message: '+ message)
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next='finished-player'
self.what_next_after_showing()
def closed_after_showing(self,reason,message):
# showing has finished with closing of player but track instance is alive for hiding the x_content
self.mon.trace(self,'')
self.mon.log(self,"Closed after showing track with reason: "+reason+ ' and message: '+ message)
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next='closed-player'
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self,show_id,reason,message):
self.mon.log(self,self.show_params['show-ref']+ ' '+ str(self.show_id)+ ': Returned from shower with ' + reason +' ' + message)
self.sr.hide_click_areas(self.controls_list)
self.req_next=reason
Show.base_end_shower(self)
self.what_next_after_showing()
# at the end of a track check for terminations else re-display the menu
def what_next_after_showing(self):
self.mon.trace(self,'')
# cancel track timeout timer
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer=None
# need to terminate?
if self.terminate_signal is True:
self.terminate_signal=False
# set what to do when closed or unloaded
self.ending_reason='killed'
Show.base_close_or_unload(self)
elif self.req_next== 'error':
self.req_next=''
# set what to do after closed or unloaded
self.ending_reason='error'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal=False
# set what to do when closed or unloaded
self.ending_reason='show-timeout'
Show.base_close_or_unload(self)
# used by exit for stopping show from other shows.
elif self.exit_signal is True:
self.exit_signal=False
self.ending_reason='exit'
Show.base_close_or_unload(self)
# user wants to stop
elif self.user_stop_signal is True:
self.user_stop_signal=False
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
elif self.next_track_signal is True:
self.next_track_signal=False
self.menu_showing=False
# start timeout for the track if required
if self.track_timeout != 0:
self.track_timeout_timer=self.canvas.after(self.track_timeout*1000,self.track_timeout_callback)
Show.write_stats(self,'play',self.show_params,self.next_track)
self.start_load_show_loop(self.next_track)
else:
# no stopping the show required so re-display the menu
self.do_menu_track()
# *********************
# Interface with other shows/players to reduce black gaps
# *********************
# called just before a track is shown to remove the previous track from the screen
# and if necessary close it
def track_ready_callback(self,enable_show_background):
self.delete_eggtimer()
if self.show_params['disable-controls'] != 'yes':
#merge controls from the track
controls_text=self.current_player.get_links()
reason,message,track_controls=self.controlsmanager.parse_controls(controls_text)
if reason == 'error':
self.mon.err(self,message + " in track: "+ self.current_player.track_params['track-ref'])
self.req_next='error'
self.what_next_after_showing()
self.controlsmanager.merge_controls(self.controls_list,track_controls)
self.sr.enable_click_areas(self.controls_list)
Show.base_track_ready_callback(self,enable_show_background)
# callback from begining of a subshow, provide previous shower player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# Ending the show
# *********************
def end(self,reason,message):
self.stop_timers()
Show.base_end(self,reason,message)
def stop_timers(self):
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer=None
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
def __init__(self):
gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
self.pipresents_issue="1.3"
self.pipresents_minorissue = '1.3.1i'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height= 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
self.pp_background='black'
StopWatch.global_enable=False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM,self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get Pi Presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
if self.options['manager'] is False:
tkMessageBox.showwarning("Pi Presents","Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path=pp_dir
self.mon=Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = ['PiPresents',
'HyperlinkShow','RadioButtonShow','ArtLiveShow','ArtMediaShow','MediaShow','LiveShow','MenuShow',
'GapShow','Show','ArtShow',
'AudioPlayer','BrowserPlayer','ImagePlayer','MenuPlayer','MessagePlayer','VideoPlayer','Player',
'MediaList','LiveList','ShowList',
'PathManager','ControlsManager','ShowManager','PluginManager',
'MplayerDriver','OMXDriver','UZBLDriver',
'KbdDriver','GPIODriver','TimeOfDay','ScreenDriver','Animate','OSCDriver',
'Network','Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue + ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue+ ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as file:
self.mon.log(self,'\nRaspbian: '+file.read())
self.mon.log(self,'\n'+check_output(["omxplayer", "-v"]))
self.mon.log(self,'\nGPU Memory: '+check_output(["vcgencmd", "get_mem", "gpu"]))
# optional other classes used
self.root=None
self.ppio=None
self.tod=None
self.animate=None
self.gpiodriver=None
self.oscdriver=None
self.osc_enabled=False
self.gpio_enabled=False
self.tod_enabled=False
self.email_enabled=False
if os.geteuid() == 0:
self.mon.err(self,'Do not run Pi Presents with sudo')
self.end('error','Do not run Pi Presents with sudo')
user=os.getenv('USER')
self.mon.log(self,'User is: '+ user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected=False
self.network_details=False
self.interface=''
self.ip=''
self.unit=''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled=False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject= '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime("%Y-%m-%d %H:%M")
message = time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email('start',subject,message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path="/pp_profiles/"+self.options['profile']
else:
self.mon.err(self,"Profile not specified in command ")
self.end('error','Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep+ 'home' + os.sep + user + os.sep+"pp_home"
else:
home = self.options['home'] + os.sep+ "pp_home"
self.mon.log(self,"pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found=False
for i in range (1, 10):
self.mon.log(self,"Trying pp_home at: " + home + " (" + str(i)+')')
if os.path.exists(home):
found=True
self.pp_home=home
break
time.sleep (1)
if found is True:
self.mon.log(self,"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self,"Failed to find pp_home directory at " + home)
self.end('error',"Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile=self.pp_home+self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self,"Running profile: " + self.pp_profile_path)
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.mon.err(self,"Failed to find requested profile: "+ self.pp_profile)
self.end('error',"Failed to find requested profile: "+ self.pp_profile)
self.mon.start_stats(self.options['profile'])
if self.options['verify'] is True:
val =Validator()
if val.validate_profile(None,pp_dir,self.pp_home,self.pp_profile,self.pipresents_issue,False) is False:
self.mon.err(self,"Validation Failed")
self.end('error','Validation Failed')
# initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error',"showlist not found at "+self.showlist_file)
# check profile and Pi Presents issues are compatible
if float(self.showlist.sissue()) != float(self.pipresents_issue):
self.mon.err(self,"Version of profile " + self.showlist.sissue() + " is not same as Pi Presents")
self.end('error',"Version of profile " + self.showlist.sissue() + " is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_show('start')
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error',"Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg=self.pp_background)
self.mon.log(self, 'native screen dimensions are ' + str(self.root.winfo_screenwidth()) + ' x ' + str(self.root.winfo_screenheight()) + ' pixcels')
if self.options['screensize'] =='':
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
else:
reason,message,self.screen_width,self.screen_height=self.parse_screen(self.options['screensize'])
if reason =='error':
self.mon.err(self,message)
self.end('error',message)
self.mon.log(self, 'commanded screen dimensions are ' + str(self.screen_width) + ' x ' + str(self.screen_height) + ' pixcels')
# set window dimensions and decorations
if self.options['fullscreen'] is False:
self.window_width=int(self.root.winfo_screenwidth()*self.nonfull_window_width)
self.window_height=int(self.root.winfo_screenheight()*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
else:
self.window_width=self.screen_width
self.window_height=self.screen_height
self.root.attributes('-fullscreen', True)
os.system('unclutter &')
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
# canvas cover the whole screen whatever the size of the window.
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
# define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.handle_user_abort)
# setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg=self.pp_background)
if self.options['fullscreen'] is True:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
else:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=1,
highlightcolor='yellow')
self.canvas.place(x=0,y=0)
# self.canvas.config(bg='black')
self.canvas.focus_set()
# ****************************************
# INITIALISE THE INPUT DRIVERS
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs/
# use keyboard driver to bind keys to symbolic names and to set up callback
kbd=KbdDriver()
if kbd.read(pp_dir,self.pp_home,self.pp_profile) is False:
self.end('error','cannot find, or error in keys.cfg')
kbd.bind_keys(self.root,self.handle_input_event)
self.sr=ScreenDriver()
# read the screen click area config file
reason,message = self.sr.read(pp_dir,self.pp_home,self.pp_profile)
if reason == 'error':
self.end('error','cannot find, or error in screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
# click areas are made on the Pi Presents canvas not the show canvases.
reason,message = self.sr.make_click_areas(self.canvas,self.handle_input_event)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
self.exitpipresents_required=False
# delete omxplayer dbus files
# if os.path.exists("/tmp/omxplayerdbus.{}".format(user)):
# os.remove("/tmp/omxplayerdbus.{}".format(user))
# if os.path.exists("/tmp/omxplayerdbus.{}.pid".format(user)):
# os.remove("/tmp/omxplayerdbus.{}.pid".format(user))
# kick off GPIO if enabled by command line option
self.gpio_enabled=False
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+os.sep+ 'gpio.cfg'):
# initialise the GPIO
self.gpiodriver=GPIODriver()
reason,message=self.gpiodriver.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,50,self.handle_input_event)
if reason == 'error':
self.end('error',message)
else:
self.gpio_enabled=True
# and start polling gpio
self.gpiodriver.poll()
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,200,self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id=-1
self.show_manager=ShowManager(show_id,self.showlist,self.starter_show,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.canvas,self.all_shows_ended_callback,self.handle_command,self.showlist)
# Register all the shows in the showlist
reason,message=self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled=False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+ os.sep + 'osc.cfg'):
self.oscdriver=OSCDriver()
reason,message=self.oscdriver.init(self.pp_profile,self.handle_command,self.handle_input_event,self.e_osc_handle_output_event)
if reason == 'error':
self.end('error',message)
else:
self.osc_enabled=True
self.root.after(1000,self.oscdriver.start_server())
# enable ToD scheduler if schedule exists
if os.path.exists(self.pp_profile + os.sep + 'schedule.json'):
self.tod_enabled = True
else:
self.tod_enabled=False
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(self,'Network not connected so Time of Day scheduler may be using the internal clock')
# warn about start shows and scheduler
if self.starter_show['start-show']=='' and self.tod_enabled is False:
self.mon.sched(self,"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(self,"No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] !='' and self.tod_enabled is True:
self.mon.sched(self,"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(self,"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod=TimeOfDay()
self.tod.init(pp_dir,self.pp_home,self.pp_profile,self.root,self.handle_command)
self.tod.poll()
# start Tkinters event loop
self.root.mainloop( )
class GapShow(Show):
"""
this is the parent class of mediashow and liveshow
The two derived clases just select the appropriate medialist from pp_medialist and pp_livelist
the parents control the monitoring
"""
# *******************
# External interface
# ********************
def __init__(self, show_id, show_params, root, canvas, showlist, pp_dir,
pp_home, pp_profile, command_callback):
# init the common bits
Show.base__init__(self, show_id, show_params, root, canvas, showlist,
pp_dir, pp_home, pp_profile, command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr = ScreenDriver()
self.controlsmanager = ControlsManager()
# Init variables special to this show
self.poll_for_interval_timer = None
self.interval_timer_signal = False
self.waiting_for_interval = False
self.interval_timer = None
self.duration_timer = None
self.end_trigger_signal = False
self.next_track_signal = False
self.previous_track_signal = False
self.play_child_signal = False
self.error_signal = False
self.show_timeout_signal = False
self.req_next = 'nil'
self.state = 'closed'
self.count = 0
self.interval = 0
self.duration = 0
self.controls_list = []
self.enable_hint = True
def play(self, end_callback, show_ready_callback, parent_kickback_signal,
level, controls_list):
self.mon.newline(3)
self.mon.trace(self, self.show_params['show-ref'])
Show.base_play(self, end_callback, show_ready_callback,
parent_kickback_signal, level, controls_list)
# unpack show parameters
reason, message, self.show_timeout = Show.calculate_duration(
self, self.show_params['show-timeout'])
if reason == 'error':
self.mon.err(
self, 'ShowTimeout has bad time: ' +
self.show_params['show-timeout'])
self.end('error', 'show timeout bad time')
self.track_count_limit = int(self.show_params['track-count-limit'])
reason, message, self.interval = Show.calculate_duration(
self, self.show_params['interval'])
if reason == 'error':
self.mon.err(
self, 'Interval has bad time: ' + self.show_params['interval'])
self.end('error', 'interval bad time')
# delete eggtimer started by the parent
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
self.start_show()
# ********************************
# Respond to external events
# ********************************
# exit received from another concurrent show
def exit(self):
Show.base_exit(self)
# terminate Pi Presents
def terminate(self):
Show.base_terminate(self)
# respond to input events
def handle_input_event(self, symbol):
self.mon.trace(self, "Sending input event to base show: " + symbol)
Show.base_handle_input_event(self, symbol)
def handle_input_event_this_show(self, symbol):
self.mon.trace(
self, "Handling input event in this show: " + symbol + " State:" +
self.state)
# check symbol against mediashow triggers
if self.state == 'waiting' and self.show_params[
'trigger-start-type'] in (
'input', 'input-persist'
) and symbol == self.show_params['trigger-start-param']:
self.mon.stats(self.show_params['type'],
self.show_params['show-ref'],
self.show_params['title'], 'start trigger', '', '',
'')
Show.delete_admin_message(self)
self.start_list()
elif self.state == 'playing' and self.show_params[
'trigger-end-type'] == 'input' and symbol == self.show_params[
'trigger-end-param']:
self.end_trigger_signal = True
if self.shower is not None:
self.shower.do_operation('stop')
elif self.current_player is not None:
self.current_player.input_pressed('stop')
elif self.state == 'playing' and self.show_params[
'trigger-next-type'] == 'input' and symbol == self.show_params[
'trigger-next-param']:
self.mon.stats(self.show_params['type'],
self.show_params['show-ref'],
self.show_params['title'], 'next trigger', '', '',
'')
self.mon.trace(self, "trigger-next-type detected; Calling next()")
self.next()
else:
# event is not a trigger so must be internal operation
operation = self.base_lookup_control(symbol, self.controls_list)
if operation != '':
self.do_operation(operation)
else:
self.mon.trace(self, "No operation found for event")
# overrides base
# service the standard operations for this show
def do_operation(self, operation):
# print 'do_operation ',operation
self.mon.trace(self, "Doing operation: " + operation)
if operation == 'exit':
self.exit()
elif operation == 'stop':
if self.level != 0:
# not at top so stop the show
self.user_stop_signal = True
# and stop the track first
if self.current_player is not None:
self.current_player.input_pressed('stop')
else:
# at top, just stop track if running
if self.current_player is not None:
self.current_player.input_pressed('stop')
elif operation == 'up' and self.state == 'playing':
# print '\nUP'
self.previous()
elif operation == 'down' and self.state == 'playing':
self.next()
elif operation == 'play':
# use 'play' to start child if state=playing or to trigger the show if waiting for trigger
if self.state == 'playing':
if self.show_params['child-track-ref'] != '':
# set a signal because must stop current track before running child show
self.play_child_signal = True
self.child_track_ref = self.show_params['child-track-ref']
# and stop the current track if its running
if self.current_player is not None:
self.current_player.input_pressed('stop')
else:
if self.state == 'waiting':
self.mon.stats(self.show_params['type'],
self.show_params['show-ref'],
self.show_params['title'], 'start trigger',
'', '', '')
Show.delete_admin_message(self)
self.start_list()
elif operation == 'pause':
if self.current_player is not None:
self.current_player.input_pressed('pause')
elif operation in ('no-command', 'null'):
return
# if the operation is omxplayer mplayer or uzbl runtime control then pass it to player if running
elif operation[0:4] == 'omx-' or operation[
0:6] == 'mplay-' or operation[0:5] == 'uzbl-':
if self.current_player is not None:
self.current_player.input_pressed(operation)
def next(self):
# stop track if running and set signal
self.next_track_signal = True
if self.shower is not None:
self.mon.trace(self, "Sending operation to current shower")
self.shower.do_operation('stop')
else:
if self.current_player is not None:
self.mon.trace(self, "Sending operation to current player")
self.current_player.input_pressed('stop')
else:
self.mon.trace(self, "There is nowhere to send the signal")
def previous(self):
self.previous_track_signal = True
if self.shower is not None:
self.shower.do_operation('stop')
else:
if self.current_player is not None:
self.current_player.input_pressed('stop')
# ***************************
# Show sequencing
# ***************************
def start_show(self):
# initial direction from parent show
self.kickback_for_next_track = self.parent_kickback_signal
# print '\n\ninital KICKBACK from parent', self.kickback_for_next_track
# start duration timer
if self.show_timeout != 0:
# print 'set alarm ', self.show_timeout
self.duration_timer = self.canvas.after(self.show_timeout * 1000,
self.show_timeout_stop)
self.first_list = True
# and start the first list of the show
self.wait_for_trigger()
def wait_for_trigger(self):
# wait for trigger sets the state to waiting so that trigger events can do a start_list.
self.state = 'waiting'
self.mon.log(
self, self.show_params['show-ref'] + ' ' + str(self.show_id) +
": Waiting for trigger: " + self.show_params['trigger-start-type'])
if self.show_params['trigger-start-type'] == "input":
#close the previous track to display admin message
Show.base_shuffle(self)
Show.base_track_ready_callback(self, False)
Show.display_admin_message(self,
self.show_params['trigger-wait-text'])
elif self.show_params['trigger-start-type'] == "input-persist":
if self.first_list == True:
#first time through track list so play the track without waiting to get to end.
self.first_list = False
self.start_list()
else:
#wait for trigger while displaying previous track
pass
elif self.show_params['trigger-start-type'] == "start":
# don't close the previous track to give seamless repeat of the show
self.start_list()
else:
self.mon.err(
self,
"Unknown trigger: " + self.show_params['trigger-start-type'])
self.end('error', "Unknown trigger type")
# timer for repeat=interval
def end_interval_timer(self):
self.interval_timer_signal = True
# print 'INTERVAL TIMER ended'
if self.shower is not None:
self.shower.do_operation('stop')
elif self.current_player is not None:
self.current_player.input_pressed('stop')
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
def start_list(self):
# starts the list or any repeat having waited for trigger first.
self.state = 'playing'
# initialise track counter for the list
self.track_count = 0
# start interval timer
self.interval_timer_signal = False
if self.interval != 0:
self.interval_timer = self.canvas.after(self.interval * 1000,
self.end_interval_timer)
#get rid of previous track in order to display the empty message
if self.medialist.display_length() == 0:
if self.show_params['empty-text']:
Show.base_shuffle(self)
Show.base_track_ready_callback(self, False)
Show.display_admin_message(self,
self.show_params['empty-text'])
self.wait_for_not_empty()
else:
self.stop_timers()
self.ending_reason = 'exit'
Show.base_close_or_unload(self)
else:
self.not_empty()
def wait_for_not_empty(self):
if self.medialist.display_length() == 0:
# list is empty retry after 5 secs
self.canvas.after(5000, self.wait_for_not_empty)
else:
Show.delete_admin_message(self)
self.not_empty()
def not_empty(self):
#get first or last track depending on direction
# print 'use direction for start or end of list', self.kickback_for_next_track
if self.kickback_for_next_track is True:
self.medialist.finish()
else:
self.medialist.start()
self.start_load_show_loop(self.medialist.selected_track())
# ***************************
# Track load/show loop
# ***************************
# track playing loop starts here
def start_load_show_loop(self, selected_track):
# shuffle players
Show.base_shuffle(self)
self.delete_eggtimer()
# is child track required
if self.show_params['child-track-ref'] != '':
self.enable_child = True
else:
self.enable_child = False
# load the track or show
# params - track,enable_menu
enable = self.enable_child & self.enable_hint
Show.base_load_track_or_show(self, selected_track,
self.what_next_after_load,
self.end_shower, enable)
# track has loaded so show it.
def what_next_after_load(self, status, message):
self.mon.log(
self, 'Show Id ' + str(self.show_id) +
' load complete with status: ' + status + ' message: ' + message)
if self.current_player.play_state == 'load-failed':
self.error_signal = True
self.what_next_after_showing()
else:
if self.terminate_signal is True or self.exit_signal is True or self.user_stop_signal is True:
self.what_next_after_showing()
else:
self.mon.trace(self, ' - showing track')
self.current_player.show(self.track_ready_callback,
self.finished_showing,
self.closed_after_showing)
def finished_showing(self, reason, message):
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.error_signal = True
else:
self.req_next = 'finished-player'
# showing has finished with 'pause at end', showing the next track will close it after next has started showing
self.mon.trace(self, ' - pause at end ')
self.mon.log(
self, "pause at end of showing track with reason: " + reason +
' and message: ' + message)
self.what_next_after_showing()
def closed_after_showing(self, reason, message):
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.error_signal = True
else:
self.req_next = 'closed-player'
# showing has finished with closing of player but track instance is alive for hiding the x_content
self.mon.trace(self, ' - closed')
self.mon.log(
self, "Closed after showing track with reason: " + reason +
' and message: ' + message)
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self, show_id, reason, message):
self.mon.log(
self, self.show_params['show-ref'] + ' ' + str(self.show_id) +
': Returned from shower with ' + reason + ' ' + message)
self.sr.hide_click_areas(self.controls_list)
self.req_next = reason
Show.base_end_shower(self)
self.what_next_after_showing()
def pretty_what_next_after_showing_state(self):
state = '\n* terminate signal ' + str(self.terminate_signal)
state += '\n* error signal ' + str(self.error_signal)
state += '\n* req_next used to indicate subshow reports an error ' + self.req_next
state += '\n* exit signal ' + str(self.exit_signal)
state += '\n* show timeout signal ' + str(self.show_timeout_signal)
state += '\n* user stop signal ' + str(self.user_stop_signal)
state += '\n* previous track signal ' + str(
self.previous_track_signal)
state += '\n* next track signal ' + str(self.next_track_signal)
state += '\n* kickback from subshow ' + str(
self.subshow_kickback_signal)
return state + '\n'
def what_next_after_showing(self):
self.mon.trace(self, self.pretty_what_next_after_showing_state())
self.track_count += 1
# set false when child rack is to be played
self.enable_hint = True
# first of all deal with conditions that do not require the next track to be shown
# some of the conditions can happen at any time, others only when a track is closed or at pause_at_end
# need to terminate
if self.terminate_signal is True:
self.terminate_signal = False
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason = 'killed'
Show.base_close_or_unload(self)
elif self.error_signal == True or self.req_next == 'error':
self.error_signal = False
self.req_next = ''
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason = 'error'
Show.base_close_or_unload(self)
# used for exiting show from other shows, time of day, external etc.
elif self.exit_signal is True:
self.exit_signal = False
self.stop_timers()
self.ending_reason = 'exit'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal = False
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# user wants to stop the show
elif self.user_stop_signal is True:
self.user_stop_signal = False
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# interval > 0. If last track has finished we are waiting for interval timer before ending the list
# note: if medialist finishes after interval is up then this route is used to start trigger.
elif self.waiting_for_interval is True:
# interval_timer_signal set by alarm clock started in start_list
if self.interval_timer_signal is True:
self.interval_timer_signal = False
self.waiting_for_interval = False
# print 'RECEIVED INTERVAL TIMER SIGNAL'
if self.show_params['repeat'] == 'repeat':
self.wait_for_trigger()
else:
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
self.poll_for_interval_timer = self.canvas.after(
1000, self.what_next_after_showing)
# has content of list been changed (replaced if it has, used for content of livelist)
# causes it to go to wait_for_trigger and start_list
#not sure why need clos_and_unload here ???????
elif self.medialist.replace_if_changed() is True:
self.ending_reason = 'change-medialist'
# print 'CHANGE REQ'
Show.base_close_or_unload(self)
# otherwise consider operation that might show the next track
else:
# setup default direction for next track as normally goes forward unless kicked back
self.kickback_for_next_track = False
# print 'init direction to False at begin of what_next_after showing', self.kickback_for_next_track
# end trigger from input, or track count
if self.end_trigger_signal is True or (self.track_count_limit > 0
and self.track_count
== self.track_count_limit):
self.end_trigger_signal = False
# repeat so test start trigger
if self.show_params['repeat'] == 'repeat':
self.stop_timers()
# print 'END TRIGGER restart'
self.wait_for_trigger()
else:
# single run so exit show
if self.level != 0:
self.kickback_for_next_track = False
self.subshow_kickback_signal = False
self.end('normal',
"End of single run - Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# user wants to play child
elif self.play_child_signal is True:
self.play_child_signal = False
index = self.medialist.index_of_track(self.child_track_ref)
if index >= 0:
# don't use select the track as need to preserve mediashow sequence for returning from child
child_track = self.medialist.track(index)
Show.write_stats(self, 'play child', self.show_params,
child_track)
self.display_eggtimer()
self.enable_hint = False
self.start_load_show_loop(child_track)
else:
self.mon.err(
self, "Child not found in medialist: " +
self.child_track_ref)
self.ending_reason = 'error'
Show.base_close_or_unload(self)
# skip to next track on user input or after subshow
elif self.next_track_signal is True:
# print 'skip forward test' ,self.subshow_kickback_signal
if self.next_track_signal is True or self.subshow_kickback_signal is False:
self.next_track_signal = False
self.kickback_for_next_track = False
if self.medialist.at_end() is True:
# medialist_at_end can give false positive for shuffle
if self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'repeat':
self.wait_for_trigger()
elif self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track = False
self.subshow_kickback_signal = False
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal', "Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do next track
self.kickback_for_next_track = False
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
# skip to previous track on user input or after subshow
elif self.previous_track_signal is True or self.subshow_kickback_signal is True:
# print 'skip backward test, subshow kickback is' ,self.subshow_kickback_signal
self.subshow_kickback_signal = False
self.previous_track_signal = False
self.kickback_for_next_track = True
# medialist_at_start can give false positive for shuffle
if self.medialist.at_start() is True:
# print 'AT START'
if self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'repeat':
self.kickback_for_next_track = True
self.wait_for_trigger()
elif self.show_params[
'sequence'] == "ordered" and self.show_params[
'repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track = True
self.subshow_kickback_signal = True
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal', "Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do previous track
self.kickback_for_next_track = True
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(
self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# AT END OF MEDIALIST
elif self.medialist.at_end() is True:
# print 'MEDIALIST AT END'
# interval>0 and list finished so wait for the interval timer
if self.show_params[
'sequence'] == "ordered" and self.interval > 0 and self.interval_timer_signal == False:
self.waiting_for_interval = True
# print 'WAITING FOR INTERVAL'
Show.base_shuffle(self)
Show.base_track_ready_callback(self, False)
self.poll_for_interval_timer = self.canvas.after(
200, self.what_next_after_showing)
# interval=0
#elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat' and self.show_params['trigger-end-type']== 'interval' and int(self.show_params['trigger-end-param']) == 0:
#self.medialist.next(self.show_params['sequence'])
# self.start_load_show_loop(self.medialist.selected_track())
# shuffling so there is no end condition, get out of end test
elif self.show_params['sequence'] == "shuffle":
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# nothing special to do at end of list, just repeat or exit
elif self.show_params['sequence'] == "ordered":
if self.show_params['repeat'] == 'repeat':
self.wait_for_trigger()
else:
# single run
# if not at top return to parent
if self.level != 0:
self.end('normal', "End of Single Run")
else:
# at top so close the show
self.stop_timers()
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
else:
self.mon.err(
self, "Unhandled playing event at end of list: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
self.end('error', "Unhandled playing event")
elif self.medialist.at_end() is False:
# nothing special just do the next track
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# unhandled state
self.mon.err(
self, "Unhandled playing event: " +
self.show_params['sequence'] + ' with ' +
self.show_params['repeat'] + " of " +
self.show_params['trigger-end-param'])
# *********************
# Interface with other shows/players to reduce black gaps
# *********************
# called just before a track is shown to remove the previous track from the screen
# and if necessary close it
def track_ready_callback(self, enable_show_background):
self.delete_eggtimer()
# get control bindings for this show
# needs to be done for each track as track can override the show controls
if self.show_params['disable-controls'] == 'yes':
self.controls_list = []
else:
reason, message, self.controls_list = self.controlsmanager.get_controls(
self.show_params['controls'])
if reason == 'error':
self.mon.err(self, message)
self.end('error', "error in controls")
return
# print 'controls',reason,self.show_params['controls'],self.controls_list
#merge controls from the track
controls_text = self.current_player.get_links()
reason, message, track_controls = self.controlsmanager.parse_controls(
controls_text)
if reason == 'error':
self.mon.err(
self, message + " in track: " +
self.current_player.track_params['track-ref'])
self.error_signal = True
self.what_next_after_showing()
self.controlsmanager.merge_controls(self.controls_list,
track_controls)
# enable the click-area that are in the list of controls
self.sr.enable_click_areas(self.controls_list)
Show.base_track_ready_callback(self, enable_show_background)
# callback from begining of a subshow, provide previous player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# End the show
# *********************
def end(self, reason, message):
Show.base_end(self, reason, message)
def stop_timers(self):
# clear outstanding time of day events for this show
# self.tod.clear_times_list(id(self))
if self.poll_for_interval_timer is not None:
self.canvas.after_cancel(self.poll_for_interval_timer)
self.poll_for_interval_timer = None
if self.interval_timer is not None:
self.canvas.after_cancel(self.interval_timer)
self.interval_timer = None
if self.duration_timer is not None:
self.canvas.after_cancel(self.duration_timer)
self.duration_timer = None
class RadioButtonShow(Show):
"""
starts at 'first-track' which can be any type of track or a show
The show has links of the form 'symbolic-name play track-ref'
An event with the symbolic-name will play the referenced track,
at the end of that track control will return to first-track
links in the tracks are ignored. Links are inherited from the show.
timeout returns to first-track
interface:
* __init__ - initlialises the show
* play - selects the first track to play (first-track)
* input_pressed, - receives user events passes them to a Shower/Player if a track is playing,
otherwise actions them depending on the symbolic name supplied
*exit - exits the show from another show, time of day scheduler or external
* terminate - aborts the show, used whan clsing or after errors
* track_ready_callback - called by the next track to be played to remove the previous track from display
* subshow_ready_callback - called by the subshow to get the last track of the parent show
* subshow_ended_callback - called at the start of a parent show to get the last track of the subshow
"""
def __init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr=ScreenDriver()
# create an instance of PathManager - only used to parse the links.
self.path = PathManager()
self.allowed_links=('play','pause','exit','return','null','no-command','stop','pause-on','pause-off','mute','unmute','go')
# init variables
self.links=[]
self.track_timeout_timer=None
self.show_timeout_timer=None
self.next_track_signal=False
self.current_track_ref=''
self.req_next=''
def play(self,end_callback,show_ready_callback,parent_kickback_signal,level,controls_list):
""" starts the hyperlink show at start-track
end_callback - function to be called when the show exits
show_ready_callback - callback to get the previous track
level is 0 when the show is top level (run from [start] or from show control)
parent_kickback_signal - not used other than it being passed to a show
"""
# need to instantiate the medialist here as in gapshow done in derived class
self.medialist=MediaList('ordered')
Show.base_play(self,end_callback,show_ready_callback, parent_kickback_signal,level,controls_list)
self.mon.trace(self,self.show_params['show-ref'])
#parse the show and track timeouts
reason,message,self.show_timeout=Show.calculate_duration(self,self.show_params['show-timeout'])
if reason =='error':
self.mon.err(self,'Show Timeout has bad time: '+self.show_params['show-timeout'])
self.end('error','show timeout, bad time: '+self.show_params['show-timeout'])
reason,message,self.track_timeout=Show.calculate_duration(self,self.show_params['track-timeout'])
if reason=='error':
self.mon.err(self,'Track Timeout has bad time: '+self.show_params['track-timeout'])
self.end('error','track timeout, bad time: '+self.show_params['track-timeout'])
# and delete eggtimer
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
self.do_first_track()
# ********************************
# Respond to external events
# ********************************
# exit received from another concurrent show
def exit(self):
self.stop_timers()
Show.base_exit(self)
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
# terminate Pi Presents
def terminate(self):
self.stop_timers()
Show.base_terminate(self)
# respond to inputs
def handle_input_event(self,symbol):
if self.show_params['controls-in-subshows']=='yes':
Show.base_handle_input_event(self,symbol)
else:
self.handle_input_event_this_show(symbol)
def handle_input_event_this_show(self,symbol):
# for radiobuttonshow the symbolic names are links to play tracks, also a limited number of in-track operations
# find the first entry in links that matches the symbol and execute its operation
self.mon.log(self, self.show_params['show-ref']+ ' Show Id: '+ str(self.show_id)+": received input event: " + symbol)
# print 'radiobuttonshow ',symbol
found,link_op,link_arg=self.path.find_link(symbol,self.links)
# print 'input event',symbol,link_op
if found is True:
if link_op == 'play':
self.do_play(link_arg)
elif link_op == 'exit':
#exit the show
self.exit()
elif link_op == 'stop':
self.stop_timers()
if self.current_player is not None:
if self.current_track_ref == self.first_track_ref and self.level != 0:
# if quiescent then set signal to stop the show when track has stopped
self.user_stop_signal=True
self.current_player.input_pressed('stop')
elif link_op== 'return':
# return to the first track
if self.current_track_ref != self.first_track_ref:
self.do_play(self.first_track_ref)
# in-track operations
elif link_op in ('pause','pause-on','pause-off','mute','unmute','go'):
if self.current_player is not None:
self.current_player.input_pressed(link_op)
elif link_op in ('no-command','null'):
return
elif link_op[0:4] == 'omx-' or link_op[0:6] == 'mplay-'or link_op[0:5] == 'uzbl-':
if self.current_player is not None:
self.current_player.input_pressed(link_op)
else:
self.mon.err(self,"unknown link command: "+ link_op)
self.end('error',"unknown link command: "+ link_op)
# *********************
# INTERNAL FUNCTIONS
# ********************
# *********************
# Show Sequencer
# *********************
def track_timeout_callback(self):
self.do_play(self.first_track_ref)
def do_play(self,track_ref):
# if track_ref != self.current_track_ref:
# cancel the show timeout when playing another track
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
# print '\n NEED NEXT TRACK'
self.next_track_signal=True
self.next_track_op='play'
self.next_track_arg=track_ref
if self.shower is not None:
# print 'current_shower not none so stopping',self.mon.id(self.current_shower)
self.shower.do_operation('stop')
elif self.current_player is not None:
# print 'current_player not none so stopping',self.mon.id(self.current_player), ' for' ,track_ref
self.current_player.input_pressed('stop')
else:
return
def do_first_track(self):
# get first-track from profile
self.first_track_ref=self.show_params['first-track-ref']
if self.first_track_ref=='':
self.mon.err(self,"first-track is blank: ")
self.end('error',"first track is blank: " )
# find the track-ref in the medialisst
index = self.medialist.index_of_track(self.first_track_ref)
if index >=0:
# don't use select the track as not using selected_track in radiobuttonshow
self.current_track_ref=self.first_track_ref
# start the show timer when displaying the first track
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
if self.show_timeout != 0:
self.show_timeout_timer=self.canvas.after(self.show_timeout*1000 ,self.show_timeout_stop)
# print 'do first track',self.current_track_ref
# and load it
self.start_load_show_loop(self.medialist.track(index))
else:
self.mon.err(self,"first-track not found in medialist: "+ self.show_params['first-track-ref'])
self.end('error',"first track not found in medialist: " + self.show_params['first-track-ref'])
# *********************
# Playing show or track
# *********************
def start_load_show_loop(self,selected_track):
# shuffle players
Show.base_shuffle(self)
# print '\nSHUFFLED previous is', self.mon.id(self.previous_player)
self.mon.trace(self,'')
self.display_eggtimer()
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer=None
# start timeout for the track if required
if self.current_track_ref != self.first_track_ref and self.track_timeout != 0:
self.track_timeout_timer=self.canvas.after(self.track_timeout*1000,self.track_timeout_callback)
# read the show links. Track links will be added by ready_callback
# needs to be done in show loop as each track adds different links to the show links
if self.show_params['disable-controls'] == 'yes':
self.links=[]
else:
reason,message,self.links=self.path.parse_links(self.show_params['links'],self.allowed_links)
if reason == 'error':
self.mon.err(self,message + " in show")
self.end('error',message + " in show")
# load the track or show
# params - track,, track loaded callback, end eshoer callback,enable_menu
Show.base_load_track_or_show(self,selected_track,self.what_next_after_load,self.end_shower,False)
# track has loaded so show it.
def what_next_after_load(self,status,message):
self.mon.trace(self, 'load complete with status: ' + status + ' message: ' +message)
# print 'LOADED TRACK ',self.mon.id(self.current_player)
if self.current_player.play_state == 'load-failed':
self.req_next='error'
self.what_next_after_showing()
else:
if self.show_timeout_signal is True or self.terminate_signal is True or self.exit_signal is True or self.user_stop_signal is True:
# print 'after load - what next'
self.what_next_after_showing()
else:
self.mon.trace(self, '- showing track')
self.current_player.show(self.track_ready_callback,self.finished_showing,self.closed_after_showing)
def finished_showing(self,reason,message):
# showing has finished with 'pause at end', showing the next track will close it after next has started showing
self.mon.trace(self,' - pause at end')
self.mon.log(self,"pause at end of showing track with reason: "+reason+ ' and message: '+ message)
self.sr.hide_click_areas(self.links)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next='finished-player'
# print 'finished showing ',self.mon.id(self.current_player),' from state ',self.current_player.play_state
self.what_next_after_showing()
def closed_after_showing(self,reason,message):
# showing has finished with closing of player but track instance is alive for hiding the x_content
self.mon.trace(self, '- closed after showing')
self.mon.log(self,"Closed after showing track with reason: "+reason+ ' and message: '+ message)
self.sr.hide_click_areas(self.links)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next='closed-player'
# print 'closed showing',self.mon.id(self.current_player),' from state ',self.current_player.play_state
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self,show_id,reason,message):
self.mon.log(self,self.show_params['show-ref']+ ' '+ str(self.show_id)+ ': Returned from shower with ' + reason +' ' + message)
self.sr.hide_click_areas(self.links)
self.req_next=reason
Show.base_end_shower(self)
# print 'end shower - wha-next'
self.what_next_after_showing()
def what_next_after_showing(self):
self.mon.trace(self, '')
# print 'WHAT NEXT AFTER SHOWING'
# print 'current is',self.mon.id(self.current_player), ' next track signal ',self.next_track_signal
# need to terminate
if self.terminate_signal is True:
self.terminate_signal=False
# what to do when closed or unloaded
self.ending_reason='killed'
Show.base_close_or_unload(self)
elif self.req_next== 'error':
self.req_next=''
# set what to do after closed or unloaded
self.ending_reason='error'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal=False
# what to do when closed or unloaded
self.ending_reason='show-timeout'
Show.base_close_or_unload(self)
# used by exit for stopping show from other shows.
elif self.exit_signal is True:
self.exit_signal=False
self.ending_reason='exit'
Show.base_close_or_unload(self)
# user wants to stop
elif self.user_stop_signal is True:
self.user_stop_signal=False
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# user has selected another track
elif self.next_track_signal is True:
self.next_track_signal=False
self.current_track_ref=self.next_track_arg
# print 'what next - next track signal is True so load ', self.current_track_ref
index = self.medialist.index_of_track(self.current_track_ref)
if index >=0:
# don't use select the track as not using selected_track in radiobuttonshow
# and load it
Show.write_stats(self,'play',self.show_params,self.medialist.track(index))
self.start_load_show_loop(self.medialist.track(index))
else:
self.mon.err(self,"track reference not found in medialist: "+ self.current_track_ref)
self.end('error',"track reference not found in medialist: "+ self.current_track_ref)
else:
# track ends naturally or is quit so go back to first track
# print 'what next - natural end so do first track'
self.do_first_track()
# *********************
# Interface with other shows/players to reduce black gaps
# *********************
# called just before a track is shown to remove the previous track from the screen
# and if necessary close it
def track_ready_callback(self,enable_show_background):
self.delete_eggtimer()
# print 'TRACK READY CALLBACK'
# print 'previous is',self.mon.id(self.previous_player), self.next_track_signal
#merge links from the track
if self.show_params['disable-controls'] == 'yes':
track_links=[]
else:
reason,message,track_links=self.path.parse_links(self.current_player.get_links(),self.allowed_links)
if reason == 'error':
self.mon.err(self,message + " in track: "+ self.current_player.track_params['track-ref'])
self.req_next='error'
self.what_next_after_showing()
self.path.merge_links(self.links,track_links)
# enable the click-area that are in the list of links
self.sr.enable_click_areas(self.links)
Show.base_track_ready_callback(self,enable_show_background)
# callback from begining of a subshow, provide previous shower player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# End the show
# *********************
def end(self,reason,message):
self.stop_timers()
Show.base_end(self,reason,message)
def stop_timers(self):
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer=None
class GapShow(Show):
"""
this is the parent class of mediashow and liveshow
The two derived clases just select the appropriate medialist from pp_medialist and pp_livelist
the parents control the monitoring
"""
# *******************
# External interface
# ********************
def __init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback):
# init the common bits
Show.base__init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr=ScreenDriver()
self.controlsmanager=ControlsManager()
# Init variables special to this show
self.poll_for_interval_timer=None
self.interval_timer_signal=False
self.waiting_for_interval=False
self.interval_timer=None
self.duration_timer=None
self.end_trigger_signal=False
self.next_track_signal=False
self.previous_track_signal=False
self.play_child_signal = False
self.error_signal=False
self.show_timeout_signal=False
self.req_next='nil'
self.state='closed'
self.count=0
self.interval=0
self.duration=0
self.controls_list=[]
self.enable_hint= True
self.escapetrack_required=False
def play(self,end_callback,show_ready_callback, parent_kickback_signal,level,controls_list):
self.mon.newline(3)
self.mon.trace(self, self.show_params['show-ref'])
Show.base_play(self,end_callback,show_ready_callback,parent_kickback_signal, level,controls_list)
# unpack show parameters
reason,message,self.show_timeout = Show.calculate_duration(self,self.show_params['show-timeout'])
if reason=='error':
self.mon.err(self,'ShowTimeout has bad time: '+self.show_params['show-timeout'])
self.end('error','ShowTimeout has bad time: '+self.show_params['show-timeout'])
self.track_count_limit = int(self.show_params['track-count-limit'])
reason,message,self.interval = Show.calculate_duration (self, self.show_params['interval'])
if reason=='error':
self.mon.err(self,'Interval has bad time: '+self.show_params['interval'])
self.end('error','Interval has bad time: '+self.show_params['interval'])
if self.medialist.anon_length()==0 and self.show_params['type'] not in ('liveshow','artliveshow'):
self.mon.err(self,'No anonymous tracks in medialist ')
self.end('error','No anonymous tracks in medialist ')
# delete eggtimer started by the parent
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
self.start_show()
# ********************************
# Respond to external events
# ********************************
# exit received from another concurrent show
def exit(self):
Show.base_exit(self)
# terminate Pi Presents
def terminate(self):
Show.base_terminate(self)
# respond to input events
def handle_input_event(self,symbol):
Show.base_handle_input_event(self,symbol)
def handle_input_event_this_show(self,symbol):
# check symbol against mediashow triggers
if self.state == 'waiting' and self.show_params['trigger-start-type'] in ('input','input-persist') and symbol == self.show_params['trigger-start-param']:
self.mon.stats(self.show_params['type'],self.show_params['show-ref'],self.show_params['title'],'start trigger',
'','','')
Show.delete_admin_message(self)
self.start_list()
elif self.state == 'playing' and self.show_params['trigger-end-type'] == 'input' and symbol == self.show_params['trigger-end-param']:
self.end_trigger_signal=True
if self.shower is not None:
self.shower.do_operation('stop')
elif self.current_player is not None:
self.current_player.input_pressed('stop')
elif self.state == 'playing' and self.show_params['trigger-next-type'] == 'input' and symbol == self.show_params['trigger-next-param']:
self.mon.stats(self.show_params['type'],self.show_params['show-ref'],self.show_params['title'],'next trigger',
'','','')
self.next()
else:
# event is not a trigger so must be internal operation
operation=self.base_lookup_control(symbol,self.controls_list)
if operation != '':
self.do_operation(operation)
# overrides base
# service the standard operations for this show
def do_operation(self,operation):
# print 'do_operation ',operation
self.mon.trace(self, operation)
if operation == 'exit':
self.exit()
elif operation == 'stop':
if self.level != 0 :
# not at top so stop the show
self.user_stop_signal=True
# and stop the track first
if self.current_player is not None:
self.current_player.input_pressed('stop')
else:
# at top, just stop track if running
if self.current_player is not None:
self.current_player.input_pressed('stop')
elif operation == 'up' and self.state == 'playing':
# print '\nUP'
self.previous()
elif operation == 'down' and self.state == 'playing':
self.next()
elif operation == 'play':
# use 'play' to start child if state=playing or to trigger the show if waiting for trigger
if self.state == 'playing':
if self.show_params['child-track-ref'] != '':
# set a signal because must stop current track before running child show
self.play_child_signal=True
self.child_track_ref=self.show_params['child-track-ref']
# and stop the current track if its running
if self.current_player is not None:
self.current_player.input_pressed('stop')
else:
if self.state == 'waiting':
self.mon.stats(self.show_params['type'],self.show_params['show-ref'],self.show_params['title'],'start trigger',
'','','')
Show.delete_admin_message(self)
self.start_list()
elif operation in ('pause','pause-on','pause-off','mute','unmute','go'):
if self.current_player is not None:
self.current_player.input_pressed(operation)
elif operation in ('no-command','null'):
return
# if the operation is omxplayer mplayer or uzbl runtime control then pass it to player if running
elif operation[0:4] == 'omx-' or operation[0:6] == 'mplay-'or operation[0:5] == 'uzbl-':
if self.current_player is not None:
self.current_player.input_pressed(operation)
def next(self):
# stop track if running and set signal
self.next_track_signal=True
if self.shower is not None:
self.shower.do_operation('stop')
else:
if self.current_player is not None:
self.current_player.input_pressed('stop')
def previous(self):
self.previous_track_signal=True
if self.shower is not None:
self.shower.do_operation('stop')
else:
if self.current_player is not None:
self.current_player.input_pressed('stop')
# ***************************
# Show sequencing
# ***************************
def start_show(self):
# initial direction from parent show
self.kickback_for_next_track=self.parent_kickback_signal
# print '\n\ninital KICKBACK from parent', self.kickback_for_next_track
# start duration timer
if self.show_timeout != 0:
# print 'set alarm ', self.show_timeout
self.duration_timer = self.canvas.after(self.show_timeout*1000,self.show_timeout_stop)
self.first_list=True
# and start the first list of the show
self.wait_for_trigger()
def wait_for_trigger(self):
# wait for trigger sets the state to waiting so that trigger events can do a start_list.
self.state='waiting'
self.mon.log(self,self.show_params['show-ref']+ ' '+ str(self.show_id)+ ": Waiting for trigger: "+ self.show_params['trigger-start-type'])
if self.show_params['trigger-start-type'] == "input":
#close the previous track to display admin message
Show.base_shuffle(self)
Show.base_track_ready_callback(self,False)
Show.display_admin_message(self,self.show_params['trigger-wait-text'])
elif self.show_params['trigger-start-type'] == "input-persist":
if self.first_list ==True:
#first time through track list so play the track without waiting to get to end.
self.start_list()
else:
#wait for trigger while displaying previous track
pass
elif self.show_params['trigger-start-type'] == "start":
# don't close the previous track to give seamless repeat of the show
self.start_list()
else:
self.mon.err(self,"Unknown trigger: "+ self.show_params['trigger-start-type'])
self.end('error',"Unknown trigger: "+ self.show_params['trigger-start-type'])
# timer for repeat=interval
def end_interval_timer(self):
self.interval_timer_signal=True
# print 'INTERVAL TIMER ended'
if self.shower is not None:
self.shower.do_operation('stop')
elif self.current_player is not None:
self.current_player.input_pressed('stop')
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
def start_list(self):
# starts the list or any repeat having waited for trigger first.
self.state='playing'
# initialise track counter for the list
self.track_count=0
# start interval timer
self.interval_timer_signal = False
if self.interval != 0:
self.interval_timer=self.canvas.after(self.interval*1000,self.end_interval_timer)
# print '\nSTART LIST', self.first_list
if self.first_list is True:
# first list so go to what next
self.what_next_after_showing()
else:
#get first or last track depending on direction
if self.kickback_for_next_track is True:
self.medialist.finish()
else:
self.medialist.start()
self.start_load_show_loop(self.medialist.selected_track())
# ***************************
# Track load/show loop
# ***************************
# track playing loop starts here
def start_load_show_loop(self,selected_track):
# uncomment the next line to write stats for every track
# Show.write_stats(self,'play a track',self.show_params,selected_track)
# shuffle players
Show.base_shuffle(self)
self.delete_eggtimer()
# is child track required
if self.show_params['child-track-ref'] != '':
self.enable_child=True
else:
self.enable_child=False
# load the track or show
# params - track,enable_menu
enable=self.enable_child & self.enable_hint
Show.base_load_track_or_show(self,selected_track,self.what_next_after_load,self.end_shower,enable)
# track has loaded so show it.
def what_next_after_load(self,status,message):
self.mon.log(self,'Show Id ' + str(self.show_id)+' load complete with status: ' + status +' message: ' +message)
if self.current_player.play_state == 'load-failed':
self.error_signal=True
self.what_next_after_showing()
else:
if self.terminate_signal is True or self.exit_signal is True or self.user_stop_signal is True:
self.what_next_after_showing()
else:
self.mon.trace(self, ' - showing track')
self.current_player.show(self.track_ready_callback,self.finished_showing,self.closed_after_showing)
def finished_showing(self,reason,message):
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.error_signal=True
else:
self.req_next='finished-player'
# showing has finished with 'pause at end', showing the next track will close it after next has started showing
self.mon.trace(self, ' - pause at end ')
self.mon.log(self,"pause at end of showing track with reason: "+reason+ ' and message: '+ message)
self.what_next_after_showing()
def closed_after_showing(self,reason,message):
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == 'show-failed':
self.error_signal=True
else:
self.req_next='closed-player'
# showing has finished with closing of player but track instance is alive for hiding the x_content
self.mon.trace(self,' - closed')
self.mon.log(self,"Closed after showing track with reason: "+reason+ ' and message: '+ message)
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self,show_id,reason,message):
self.mon.log(self,self.show_params['show-ref']+ ' '+ str(self.show_id)+ ': Returned from shower with ' + reason +' ' + message)
self.sr.hide_click_areas(self.controls_list)
self.req_next=reason
Show.base_end_shower(self)
self.what_next_after_showing()
def pretty_what_next_after_showing_state(self):
state = '\n* terminate signal ' + str(self.terminate_signal)
state += '\n* error signal ' + str(self.error_signal)
state += '\n* req_next used to indicate subshow reports an error ' + self.req_next
state += '\n* exit signal ' + str(self.exit_signal)
state += '\n* show timeout signal ' + str(self.show_timeout_signal)
state += '\n* user stop signal ' + str(self.user_stop_signal)
state += '\n* previous track signal ' + str(self.previous_track_signal)
state += '\n* next track signal ' + str(self.next_track_signal)
state += '\n* kickback from subshow ' + str(self.subshow_kickback_signal)
return state +'\n'
def what_next_after_showing(self):
# print 'WHAT NEXT'
self.mon.trace(self,self.pretty_what_next_after_showing_state())
self.track_count+=1
# set false when child rack is to be played
self.enable_hint=True
# first of all deal with conditions that do not require the next track to be shown
# some of the conditions can happen at any time, others only when a track is closed or at pause_at_end
# need to terminate
if self.terminate_signal is True:
self.terminate_signal=False
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason='killed'
Show.base_close_or_unload(self)
elif self.error_signal== True or self.req_next=='error':
self.error_signal=False
self.req_next=''
self.stop_timers()
# set what to do after closed or unloaded
self.ending_reason='error'
Show.base_close_or_unload(self)
# used for exiting show from other shows, time of day, external etc.
elif self.exit_signal is True:
self.exit_signal=False
self.stop_timers()
self.ending_reason='exit'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal=False
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# user wants to stop the show
elif self.user_stop_signal is True:
self.user_stop_signal=False
# print 'user stop'
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# interval > 0. If last track has finished we are waiting for interval timer before ending the list
# note: if medialist finishes after interval is up then this route is used to start trigger.
elif self.waiting_for_interval is True:
# interval_timer_signal set by alarm clock started in start_list
if self.interval_timer_signal is True:
self.interval_timer_signal=False
self.waiting_for_interval=False
# print 'RECEIVED INTERVAL TIMER SIGNAL'
if self.show_params['repeat']=='repeat':
self.wait_for_trigger()
else:
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
self.poll_for_interval_timer=self.canvas.after(1000,self.what_next_after_showing)
else:
self.medialist.create_new_livelist()
escapetrack_required=self.escapetrack_required
self.escapetrack_required=False
# print escapetrack_required,self.medialist.new_length()
if escapetrack_required is True and self.medialist.new_length() == 0:
# print 'use escape track'
index = self.medialist.index_of_track(self.show_params['escape-track-ref'])
self.mon.log(self,'Starting Escape Track: '+ self.show_params['escape-track-ref'])
if index >=0:
# don't use select the track as need to preserve mediashow sequence for returning from esacpe track
escape_track=self.medialist.track(index)
Show.write_stats(self,'play escape track',self.show_params,escape_track)
self.display_eggtimer()
# use new empty livelist so if changed works OK when return from empty track
self.medialist.use_new_livelist()
self.start_load_show_loop(escape_track)
else:
self.mon.err(self,"Escape Track empty")
self.end('error',"Escape Track empty")
# print 'FOR IF CHANGED',self.first_list,self.medialist.length(),self.medialist.new_length(),self.medialist.livelist_changed()
elif self.first_list is True or self.medialist.livelist_changed() is True or (self.medialist.length() == 0 and self.medialist.new_length() == 0):
if self.first_list is False:
# do show control
if self.medialist.length() == 0 and self.medialist.new_length() != 0:
# print 'show control empty to not empty'
# do show control when goes from not empty to empty only
self.show_control(self.show_params['show-control-not-empty'])
elif self.medialist.length() != 0 and self.medialist.new_length() == 0:
# print 'show control not empty to empty'
# do show control when goes from empty to not empty only
self.show_control(self.show_params['show-control-empty'])
self.first_list=False
if self.medialist.new_length()==0 and self.show_params['repeat']=='repeat':
# start empty track/show
index = self.medialist.index_of_track(self.show_params['empty-track-ref'])
self.mon.log(self,'Starting Empty Track: '+ self.show_params['empty-track-ref'])
if index >=0:
# don't use select the track as need to preserve mediashow sequence for returning from empty track/show
empty_track=self.medialist.track(index)
# print 'play empty track', empty_track['title'],empty_track['type']
Show.write_stats(self,'play empty track',self.show_params,empty_track)
if empty_track['type'] =='show':
self.escapetrack_required=True
self.display_eggtimer()
# use new empty livelist so if changed works OK when return from empty track
self.medialist.use_new_livelist()
self.start_load_show_loop(empty_track)
else:
self.mon.err(self,"List Empty Track not specified")
self.end('error',"List Empty Track not specified")
elif self.medialist.new_length()==0 and self.show_params['repeat']=='single-run':
if self.level != 0:
self.kickback_for_next_track=False
self.subshow_kickback_signal=False
self.end('normal',"End of single run - Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
#changed but new is not zero
self.medialist.use_new_livelist()
# print 'livelist changed and not empty'
self.start_list()
# otherwise consider operation that might show the next track
else:
# print 'ELSE',self.medialist.at_end()
# report error if medilaist is empty (liveshow will not get this far
if self.medialist.length()==0:
self.mon.err(self,"Medialist empty")
self.end('error',"Medialist empty")
# setup default direction for next track as normally goes forward unless kicked back
self.kickback_for_next_track=False
# print 'init direction to False at begin of what_next_after showing', self.kickback_for_next_track
# end trigger from input, or track count
if self.end_trigger_signal is True or (self.track_count_limit >0 and self.track_count == self.track_count_limit):
self.end_trigger_signal=False
# repeat so test start trigger
if self.show_params['repeat'] == 'repeat':
self.stop_timers()
# print 'END TRIGGER restart'
self.wait_for_trigger()
else:
# single run so exit show
if self.level != 0:
self.kickback_for_next_track=False
self.subshow_kickback_signal=False
# print 'single run exit subshow'
self.end('normal',"End of single run - Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
# print 'ENDING'
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# user wants to play child
elif self.play_child_signal is True:
self.play_child_signal=False
index = self.medialist.index_of_track(self.child_track_ref)
if index >=0:
# don't use select the track as need to preserve mediashow sequence for returning from child
child_track=self.medialist.track(index)
Show.write_stats(self,'play child',self.show_params,child_track)
self.display_eggtimer()
self.enable_hint=False
self.start_load_show_loop(child_track)
else:
self.mon.err(self,"Child not found in medialist: "+ self.child_track_ref)
self.ending_reason='error'
Show.base_close_or_unload(self)
# skip to next track on user input or after subshow
elif self.next_track_signal is True:
# print 'skip forward test' ,self.subshow_kickback_signal
if self.next_track_signal is True or self.subshow_kickback_signal is False:
self.next_track_signal=False
self.kickback_for_next_track=False
if self.medialist.at_end() is True:
# medialist_at_end can give false positive for shuffle
if self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat':
self.wait_for_trigger()
elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track=False
self.subshow_kickback_signal=False
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal',"Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do next track
self.kickback_for_next_track=False
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# skip to previous track on user input or after subshow
elif self.previous_track_signal is True or self.subshow_kickback_signal is True:
# print 'skip backward test, subshow kickback is' ,self.subshow_kickback_signal
self.subshow_kickback_signal=False
self.previous_track_signal=False
self.kickback_for_next_track=True
# medialist_at_start can give false positive for shuffle
if self.medialist.at_start() is True:
# print 'AT START'
if self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat':
self.kickback_for_next_track=True
self.wait_for_trigger()
elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'single-run':
if self.level != 0:
self.kickback_for_next_track=True
self.subshow_kickback_signal=True
# print 'end subshow skip forward test, self. direction is ' ,self.kickback_for_next_track
self.end('normal',"Return from Sub Show")
else:
# end of single run and at top - exit the show
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
# shuffling - just do previous track
self.kickback_for_next_track=True
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# not at end just do next track
self.medialist.previous(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# AT END OF MEDIALIST
elif self.medialist.at_end() is True:
# print 'MEDIALIST AT END'
# interval>0 and list finished so wait for the interval timer
if self.show_params['sequence'] == "ordered" and self.interval > 0 and self.interval_timer_signal==False:
self.waiting_for_interval=True
# print 'WAITING FOR INTERVAL'
Show.base_shuffle(self)
Show.base_track_ready_callback(self,False)
self.poll_for_interval_timer=self.canvas.after(200,self.what_next_after_showing)
# interval=0
#elif self.show_params['sequence'] == "ordered" and self.show_params['repeat'] == 'repeat' and self.show_params['trigger-end-type']== 'interval' and int(self.show_params['trigger-end-param']) == 0:
#self.medialist.next(self.show_params['sequence'])
# self.start_load_show_loop(self.medialist.selected_track())
# shuffling so there is no end condition, get out of end test
elif self.show_params['sequence'] == "shuffle":
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
# nothing special to do at end of list, just repeat or exit
elif self.show_params['sequence'] == "ordered":
if self.show_params['repeat'] == 'repeat':
# print 'repeating at end of list'
self.wait_for_trigger()
else:
# single run
# if not at top return to parent
if self.level !=0:
self.end('normal',"End of Single Run")
else:
# at top so close the show
# print 'closing show'
self.stop_timers()
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
else:
self.mon.err(self,"Unhandled playing event at end of list: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
self.end('error',"Unhandled playing event at end of list: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
elif self.medialist.at_end() is False:
# nothing special just do the next track
# print 'nothing special'
self.medialist.next(self.show_params['sequence'])
self.start_load_show_loop(self.medialist.selected_track())
else:
# unhandled state
self.mon.err(self,"Unhandled playing event: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
self.end('error',"Unhandled playing event: "+self.show_params['sequence'] +' with ' + self.show_params['repeat']+" of "+ self.show_params['trigger-end-param'])
# *********************
# Interface with other shows/players to reduce black gaps
# *********************
# called just before a track is shown to remove the previous track from the screen
# and if necessary close it
def track_ready_callback(self,enable_show_background):
self.delete_eggtimer()
# get control bindings for this show
# needs to be done for each track as track can override the show controls
if self.show_params['disable-controls'] == 'yes':
self.controls_list=[]
else:
reason,message,self.controls_list= self.controlsmanager.get_controls(self.show_params['controls'])
if reason=='error':
self.mon.err(self,message)
self.end('error',"error in controls: " + message)
return
# print 'controls',reason,self.show_params['controls'],self.controls_list
#merge controls from the track
controls_text=self.current_player.get_links()
reason,message,track_controls=self.controlsmanager.parse_controls(controls_text)
if reason == 'error':
self.mon.err(self,message + " in track: "+ self.current_player.track_params['track-ref'])
self.error_signal=True
self.what_next_after_showing()
self.controlsmanager.merge_controls(self.controls_list,track_controls)
# enable the click-area that are in the list of controls
self.sr.enable_click_areas(self.controls_list)
Show.base_track_ready_callback(self,enable_show_background)
# callback from begining of a subshow, provide previous player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# End the show
# *********************
def end(self,reason,message):
Show.base_end(self,reason,message)
def stop_timers(self):
# clear outstanding time of day events for this show
# self.tod.clear_times_list(id(self))
if self.poll_for_interval_timer is not None:
self.canvas.after_cancel(self.poll_for_interval_timer)
self.poll_for_interval_timer=None
if self.interval_timer is not None:
self.canvas.after_cancel(self.interval_timer)
self.interval_timer=None
if self.duration_timer is not None:
self.canvas.after_cancel(self.duration_timer)
self.duration_timer=None
class PiPresents(object):
def pipresents_version(self):
vitems = self.pipresents_issue.split('.')
if len(vitems) == 2:
# cope with 2 digit version numbers before 1.3.2
return 1000 * int(vitems[0]) + 100 * int(vitems[1])
else:
return 1000 * int(vitems[0]) + 100 * int(vitems[1]) + int(
vitems[2])
def __init__(self):
# gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
gc.set_debug(gc.DEBUG_UNCOLLECTABLE | gc.DEBUG_SAVEALL)
self.pipresents_issue = "1.4.4"
self.pipresents_minorissue = '1.4.4e'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height = 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y = 0 # position of top left corner
StopWatch.global_enable = False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM, self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options = command_options()
# print (self.options)
# get Pi Presents code directory
pp_dir = sys.path[0]
self.pp_dir = pp_dir
if not os.path.exists(pp_dir + "/pipresents.py"):
if self.options['manager'] is False:
tkinter.messagebox.showwarning("Pi Presents",
"Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path = pp_dir
self.mon = Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = [
'PiPresents', 'HyperlinkShow', 'RadioButtonShow', 'ArtLiveShow',
'ArtMediaShow', 'MediaShow', 'LiveShow', 'MenuShow', 'GapShow',
'Show', 'ArtShow', 'AudioPlayer', 'BrowserPlayer', 'ImagePlayer',
'MenuPlayer', 'MessagePlayer', 'VideoPlayer', 'Player',
'MediaList', 'LiveList', 'ShowList', 'PathManager',
'ControlsManager', 'ShowManager', 'TrackPluginManager',
'IOPluginManager', 'MplayerDriver', 'OMXDriver', 'UZBLDriver',
'TimeOfDay', 'ScreenDriver', 'Animate', 'OSCDriver',
'CounterManager', 'BeepsManager', 'Network', 'Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# Monitor.classes=['OSCDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched(
self, None,
"Pi Presents is starting, Version:" + self.pipresents_minorissue +
' at ' + time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log(
self,
"Pi Presents is starting, Version:" + self.pipresents_minorissue +
' at ' + time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self, "sys.path[0] - location of code: " + sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as ifile:
self.mon.log(self, '\nRaspbian: ' + ifile.read())
self.mon.log(
self,
'\n' + check_output(["omxplayer", "-v"], universal_newlines=True))
self.mon.log(
self,
'\nGPU Memory: ' + check_output(["vcgencmd", "get_mem", "gpu"],
universal_newlines=True))
if os.geteuid() == 0:
print('Do not run Pi Presents with sudo')
self.mon.log(self, 'Do not run Pi Presents with sudo')
self.mon.finish()
sys.exit(102)
if "DESKTOP_SESSION" not in os.environ:
print('Pi Presents must be run from the Desktop')
self.mon.log(self, 'Pi Presents must be run from the Desktop')
self.mon.finish()
sys.exit(102)
else:
self.mon.log(self, 'Desktop is ' + os.environ['DESKTOP_SESSION'])
# optional other classes used
self.root = None
self.ppio = None
self.tod = None
self.dm = None
self.animate = None
self.ioplugin_manager = None
self.oscdriver = None
self.osc_enabled = False
self.tod_enabled = False
self.email_enabled = False
user = os.getenv('USER')
if user is None:
tkinter.messagebox.showwarning(
"You must be logged in to run Pi Presents")
exit(102)
if user != 'pi':
self.mon.warn(self, "You must be logged as pi to use GPIO")
self.mon.log(self, 'User is: ' + user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected = False
self.network_details = False
self.interface = ''
self.ip = ''
self.unit = ''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled = False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject = '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime(
"%Y-%m-%d %H:%M")
message = time.strftime(
"%Y-%m-%d %H:%M"
) + '\nUnit: ' + self.unit + ' Profile: ' + self.options[
'profile'] + '\n ' + self.interface + '\n ' + self.ip
self.send_email('start', subject, message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path = "/pp_profiles/" + self.options['profile']
else:
self.mon.err(self, "Profile not specified in command ")
self.end('error',
'Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep + 'home' + os.sep + user + os.sep + "pp_home"
else:
home = self.options['home'] + os.sep + "pp_home"
self.mon.log(self, "pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found = False
for i in range(1, 10):
self.mon.log(self,
"Trying pp_home at: " + home + " (" + str(i) + ')')
if os.path.exists(home):
found = True
self.pp_home = home
break
time.sleep(1)
if found is True:
self.mon.log(
self,
"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self, "Failed to find pp_home directory at " + home)
self.end('error', "Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile = self.pp_home + self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self, None,
"Running profile: " + self.pp_profile_path)
self.mon.log(
self, "Found Requested profile - pp_profile directory is: " +
self.pp_profile)
else:
self.mon.err(
self, "Failed to find requested profile: " + self.pp_profile)
self.end('error',
"Failed to find requested profile: " + self.pp_profile)
self.mon.start_stats(self.options['profile'])
# initialise and read the showlist in the profile
self.showlist = ShowList()
self.showlist_file = self.pp_profile + "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self, "showlist not found at " + self.showlist_file)
self.end('error', "showlist not found at " + self.showlist_file)
# check profile and Pi Presents issues are compatible
if self.showlist.profile_version() != self.pipresents_version():
self.mon.err(
self,
"Version of showlist " + self.showlist.profile_version_string +
" is not same as Pi Presents")
self.end(
'error',
"Version of showlist " + self.showlist.profile_version_string +
" is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_start_show()
if index >= 0:
self.showlist.select(index)
self.starter_show = self.showlist.selected_show()
else:
self.mon.err(self, "Show [start] not found in showlist")
self.end('error', "Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset", "s", "off"])
call(["xset", "s", "-dpms"])
# find connected displays and create a canvas for each display
self.dm = DisplayManager()
status, message, self.root = self.dm.init(self.options,
self.handle_user_abort,
self.pp_dir)
if status != 'normal':
self.mon.err(self, message)
self.end('error', message)
self.mon.log(
self,
str(DisplayManager.num_displays) + ' Displays are connected:')
for display_id in DisplayManager.displays:
if self.dm.has_canvas(display_id):
canvas_obj = self.dm.canvas_widget(display_id)
canvas_obj.config(bg=self.starter_show['background-colour'])
name = self.dm.name_of_display(display_id)
width, height = self.dm.real_display_dimensions(display_id)
x, y = self.dm.real_display_position(display_id)
matrix, ms = self.dm.touch_matrix_for(display_id)
rotation = self.dm.real_display_orientation(display_id)
self.mon.log(
self, ' - ' + name + ' Id: ' + str(display_id) + ' ' +
str(x) + '+' + str(y) + '+' + str(width) + '*' + str(height) +
' ' + rotation)
self.mon.log(self, ' ' + ms)
status, message, driver_name = self.dm.get_driver_name(display_id)
if status == 'normal':
self.mon.log(self,
name + ': Touch Driver: ' + driver_name + '\n')
elif status == 'null':
self.mon.log(self, name + ': Touch Driver not Defined\n')
else:
self.mon.err(self, message)
# ****************************************
# INITIALISE THE TOUCHSCREEN DRIVER
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs
self.sr = ScreenDriver()
# read the screen click area config file
reason, message = self.sr.read(pp_dir, self.pp_home, self.pp_profile)
if reason == 'error':
self.end('error', 'cannot find, or error in screen.cfg')
# create click areas on the canvases, must be polygon as outline rectangles are not filled as far as find_closest goes
reason, message = self.sr.make_click_areas(self.handle_input_event)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required = False
self.reboot_required = False
self.terminate_required = False
self.exitpipresents_required = False
# initialise the Beeps Manager
self.beepsmanager = BeepsManager()
self.beepsmanager.init(self.pp_home, self.pp_profile)
# initialise the I/O plugins by importing their drivers
self.ioplugin_manager = IOPluginManager()
reason, message = self.ioplugin_manager.init(self.pp_dir,
self.pp_profile,
self.root,
self.handle_input_event,
self.pp_home)
if reason == 'error':
# self.mon.err(self,message)
self.end('error', message)
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir, self.pp_home, self.pp_profile, self.root,
200, self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id = -1
self.show_manager = ShowManager(show_id, self.showlist,
self.starter_show, self.root,
self.pp_dir, self.pp_profile,
self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.all_shows_ended_callback,
self.handle_command, self.showlist)
# Register all the shows in the showlist
reason, message = self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled = False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config' +
os.sep + 'osc.cfg'):
self.oscdriver = OSCDriver()
reason, message = self.oscdriver.init(
self.pp_profile, self.unit, self.interface, self.ip,
self.handle_command, self.handle_input_event,
self.e_osc_handle_animate)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
else:
self.osc_enabled = True
self.root.after(1000, self.oscdriver.start_server())
# initialise ToD scheduler calculating schedule for today
self.tod = TimeOfDay()
reason, message, self.tod_enabled = self.tod.init(
pp_dir, self.pp_home, self.pp_profile, self.showlist, self.root,
self.handle_command)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(
self,
'Network not connected so Time of Day scheduler may be using the internal clock'
)
# init the counter manager
self.counter_manager = CounterManager()
if self.starter_show['counters-store'] == 'yes':
store_enable = True
else:
store_enable = False
reason, message = self.counter_manager.init(
self.pp_profile + '/counters.cfg', store_enable,
self.options['loadcounters'],
self.starter_show['counters-initial'])
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# warn about start shows and scheduler
if self.starter_show['start-show'] == '' and self.tod_enabled is False:
self.mon.sched(
self, None,
"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(
self, "No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] != '' and self.tod_enabled is True:
self.mon.sched(
self, None,
"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(
self,
"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod.poll()
# start the I/O plugins input event generation
self.ioplugin_manager.start()
# start Tkinters event loop
self.root.mainloop()
# *********************
# RUN START SHOWS
# ********************
def run_start_shows(self):
self.mon.trace(self, 'run start shows')
# parse the start shows field and start the initial shows
show_refs = self.starter_show['start-show'].split()
for show_ref in show_refs:
reason, message = self.show_manager.control_a_show(
show_ref, 'open')
if reason == 'error':
self.mon.err(self, message)
self.end(reason, message)
# *********************
# User inputs
# ********************
def e_osc_handle_animate(self, line):
#jump out of server thread
self.root.after(1, lambda arg=line: self.osc_handle_animate(arg))
def osc_handle_animate(self, line):
self.mon.log(self, "animate command received: " + line)
#osc sends output events as a string
reason, message, delay, name, param_type, param_values = self.animate.parse_animate_fields(
line)
if reason == 'error':
self.mon.err(self, message)
self.end(reason, message)
self.handle_output_event(name, param_type, param_values, 0)
# output events are animate commands
def handle_output_event(self, symbol, param_type, param_values, req_time):
reason, message = self.ioplugin_manager.handle_output_event(
symbol, param_type, param_values, req_time)
if reason == 'error':
self.mon.err(self, message)
self.end(reason, message)
# all input events call this callback providing a symbolic name.
# handle events that affect PP overall, otherwise pass to all active shows
def handle_input_event(self, symbol, source):
self.mon.log(self, "event received: " + symbol + ' from ' + source)
if symbol == 'pp-terminate':
self.handle_user_abort()
elif symbol == 'pp-shutdown':
self.mon.err(
self,
'pp-shutdown removed in version 1.3.3a, see Release Notes')
self.end(
'error',
'pp-shutdown removed in version 1.3.3a, see Release Notes')
elif symbol == 'pp-shutdownnow':
# need root.after to get out of st thread
self.root.after(1, self.shutdownnow_pressed)
return
elif symbol == 'pp-exitpipresents':
self.exitpipresents_required = True
if self.show_manager.all_shows_exited() is True:
# need root.after to grt out of st thread
self.root.after(1, self.e_all_shows_ended_callback)
return
reason, message = self.show_manager.exit_all_shows()
else:
# pass the input event to all registered shows
for show in self.show_manager.shows:
show_obj = show[ShowManager.SHOW_OBJ]
if show_obj is not None:
show_obj.handle_input_event(symbol)
# commands are generated by tracks and shows
# they can open or close shows, generate input events and do special tasks
# commands also generate osc outputs to other computers
# handles one command provided as a line of text
def handle_command(self, command_text, source='', show=''):
# print 'PIPRESENTS ',command_text,'\n Source',source,'from',show
self.mon.log(self, "command received: " + command_text)
if command_text.strip() == "":
return
fields = command_text.split()
if fields[0] in ('osc', 'OSC'):
if self.osc_enabled is True:
status, message = self.oscdriver.parse_osc_command(fields[1:])
if status == 'warn':
self.mon.warn(self, message)
if status == 'error':
self.mon.err(self, message)
self.end('error', message)
return
else:
return
if fields[0] == 'counter':
status, message = self.counter_manager.parse_counter_command(
fields[1:])
if status == 'error':
self.mon.err(self, message)
self.end('error', message)
return
if fields[0] == 'beep':
# cheat, field 0 will always be beep
message, fields = self.beepsmanager.parse_beep(command_text)
if message != '':
self.mon.err(self, message)
self.end('error', message)
return
location = self.beepsmanager.complete_path(fields[1])
if len(fields) == 3:
device = fields[2]
else:
device = ''
if not os.path.exists(location):
message = 'Beep file does not exist: ' + location
self.mon.err(self, message)
self.end('error', message)
return
else:
self.beepsmanager.do_beep(location, device)
return
if fields[0] == 'backlight':
# on, off, inc val, dec val, set val fade val duration
status, message = self.dm.do_backlight_command(command_text)
if status == 'error':
self.mon.err(self, message)
self.end('error', message)
return
return
if fields[0] == 'monitor':
status, message = self.dm.handle_monitor_command(fields[1:])
if status == 'error':
self.mon.err(self, message)
self.end('error', message)
return
return
# show commands
show_command = fields[0]
if len(fields) > 1:
show_ref = fields[1]
else:
show_ref = ''
if show_command in ('open', 'close', 'closeall', 'openexclusive'):
self.mon.sched(self, TimeOfDay.now,
command_text + ' received from show:' + show)
if self.shutdown_required is False and self.terminate_required is False:
reason, message = self.show_manager.control_a_show(
show_ref, show_command)
else:
return
elif show_command == 'cec':
self.handle_cec_command(show_ref)
return
elif show_command == 'event':
self.handle_input_event(show_ref, 'Show Control')
return
elif show_command == 'exitpipresents':
self.exitpipresents_required = True
if self.show_manager.all_shows_exited() is True:
# need root.after to get out of st thread
self.root.after(1, self.e_all_shows_ended_callback)
return
else:
reason, message = self.show_manager.exit_all_shows()
elif show_command == 'shutdownnow':
# need root.after to get out of st thread
self.root.after(1, self.shutdownnow_pressed)
return
elif show_command == 'reboot':
# need root.after to get out of st thread
self.root.after(1, self.reboot_pressed)
return
else:
reason = 'error'
message = 'command not recognised: ' + show_command
if reason == 'error':
self.mon.err(self, message)
return
def handle_cec_command(self, command):
if command == 'on':
os.system('echo "on 0" | cec-client -s')
elif command == 'standby':
os.system('echo "standby 0" | cec-client -s')
elif command == 'scan':
os.system('echo scan | cec-client -s -d 1')
# deal with differnt commands/input events
def shutdownnow_pressed(self):
self.shutdown_required = True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal', 'no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def reboot_pressed(self):
self.reboot_required = True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal', 'no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def handle_sigterm(self, signum, fframe):
self.mon.log(self, 'SIGTERM received - ' + str(signum))
self.terminate()
def handle_user_abort(self):
self.mon.log(self, 'User abort received')
self.terminate()
def terminate(self):
self.mon.log(self, "terminate received")
self.terminate_required = True
needs_termination = False
for show in self.show_manager.shows:
# print show[ShowManager.SHOW_OBJ], show[ShowManager.SHOW_REF]
if show[ShowManager.SHOW_OBJ] is not None:
needs_termination = True
self.mon.log(
self,
"Sent terminate to show " + show[ShowManager.SHOW_REF])
# call shows terminate method
# eventually the show will exit and after all shows have exited all_shows_callback will be executed.
show[ShowManager.SHOW_OBJ].terminate()
if needs_termination is False:
self.end('killed', 'killed - no termination of shows required')
# ******************************
# Ending Pi Presents after all the showers and players are closed
# **************************
def e_all_shows_ended_callback(self):
self.all_shows_ended_callback('normal', 'no shows running')
# callback from ShowManager when all shows have ended
def all_shows_ended_callback(self, reason, message):
for display_name in DisplayManager.display_map:
status, message, display_id, canvas_obj = self.dm.id_of_canvas(
display_name)
if status != 'normal':
continue
canvas_obj.config(bg=self.starter_show['background-colour'])
if reason in (
'killed', 'error'
) or self.shutdown_required is True or self.exitpipresents_required is True or self.reboot_required is True:
self.end(reason, message)
def end(self, reason, message):
self.mon.log(self, "Pi Presents ending with reason: " + reason)
if self.root is not None:
self.root.destroy()
self.tidy_up()
if reason == 'killed':
if self.email_enabled is True and self.mailer.email_on_terminate is True:
subject = '[Pi Presents] ' + self.unit + ': PP Exited with reason: Terminated'
message = time.strftime(
"%Y-%m-%d %H:%M"
) + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason, subject, message)
self.mon.sched(self, None, "Pi Presents Terminated, au revoir\n")
self.mon.log(self, "Pi Presents Terminated, au revoir")
# close logging files
self.mon.finish()
print('Uncollectable Garbage', gc.collect())
# objgraph.show_backrefs(objgraph.by_type('Canvas'),filename='backrefs.png')
sys.exit(101)
elif reason == 'error':
if self.email_enabled is True and self.mailer.email_on_error is True:
subject = '[Pi Presents] ' + self.unit + ': PP Exited with reason: Error'
message_text = 'Download log for error message\n' + time.strftime(
"%Y-%m-%d %H:%M"
) + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason, subject, message_text)
self.mon.sched(self, None,
"Pi Presents closing because of error, sorry\n")
self.mon.log(self, "Pi Presents closing because of error, sorry")
# close logging files
self.mon.finish()
print('uncollectable garbage', gc.collect())
sys.exit(102)
else:
self.mon.sched(self, None, "Pi Presents exiting normally, bye\n")
self.mon.log(self, "Pi Presents exiting normally, bye")
# close logging files
self.mon.finish()
if self.reboot_required is True:
# print 'REBOOT'
call(['sudo', 'reboot'])
if self.shutdown_required is True:
# print 'SHUTDOWN'
call(['sudo', 'shutdown', 'now', 'SHUTTING DOWN'])
print('uncollectable garbage', gc.collect())
sys.exit(100)
# tidy up all the peripheral bits of Pi Presents
def tidy_up(self):
self.mon.log(self, "Tidying Up")
if self.dm != None:
self.dm.handle_monitor_command(['reset'])
# turn screen blanking back on
if self.options['noblank'] is True:
call(["xset", "s", "on"])
call(["xset", "s", "+dpms"])
# tidy up animation
if self.animate is not None:
self.animate.terminate()
# tidy up i/o plugins
if self.ioplugin_manager != None:
self.ioplugin_manager.terminate()
if self.osc_enabled is True:
self.oscdriver.terminate()
# tidy up time of day scheduler
if self.tod_enabled is True:
self.tod.terminate()
# *******************************
# Connecting to network and email
# *******************************
def init_network(self):
timeout = int(self.options['nonetwork'])
if timeout == 0:
self.network_connected = False
self.unit = ''
self.ip = ''
self.interface = ''
return
self.network = Network()
self.network_connected = False
# try to connect to network
self.mon.log(self,
'Waiting up to ' + str(timeout) + ' seconds for network')
success = self.network.wait_for_network(timeout)
if success is False:
self.mon.warn(
self, 'Failed to connect to network after ' + str(timeout) +
' seconds')
# tkMessageBox.showwarning("Pi Presents","Failed to connect to network so using fake-hwclock")
return
self.network_connected = True
self.mon.sched(
self, None, 'Time after network check is ' +
time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log(
self, 'Time after network check is ' +
time.strftime("%Y-%m-%d %H:%M.%S"))
# Get web configuration
self.network_details = False
network_options_file_path = self.pp_dir + os.sep + 'pp_config' + os.sep + 'pp_web.cfg'
if not os.path.exists(network_options_file_path):
self.mon.warn(
self, "pp_web.cfg not found at " + network_options_file_path)
return
self.mon.log(self, 'Found pp_web.cfg in ' + network_options_file_path)
self.network.read_config(network_options_file_path)
self.unit = self.network.unit
# get interface and IP details of preferred interface
self.interface, self.ip = self.network.get_preferred_ip()
if self.interface == '':
self.network_connected = False
return
self.network_details = True
self.mon.log(
self, 'Network details ' + self.unit + ' ' + self.interface + ' ' +
self.ip)
def init_mailer(self):
self.email_enabled = False
email_file_path = self.pp_dir + os.sep + 'pp_config' + os.sep + 'pp_email.cfg'
if not os.path.exists(email_file_path):
self.mon.log(self, 'pp_email.cfg not found at ' + email_file_path)
return
self.mon.log(self, 'Found pp_email.cfg at ' + email_file_path)
self.mailer = Mailer()
self.mailer.read_config(email_file_path)
# all Ok so can enable email if config file allows it.
if self.mailer.email_allowed is True:
self.email_enabled = True
self.mon.log(self, 'Email Enabled')
def try_connect(self):
tries = 1
while True:
success, error = self.mailer.connect()
if success is True:
return True
else:
self.mon.log(
self, 'Failed to connect to email SMTP server ' +
str(tries) + '\n ' + str(error))
tries += 1
if tries > 5:
self.mon.log(
self, 'Failed to connect to email SMTP server after ' +
str(tries))
return False
def send_email(self, reason, subject, message):
if self.try_connect() is False:
return False
else:
success, error = self.mailer.send(subject, message)
if success is False:
self.mon.log(self, 'Failed to send email: ' + str(error))
success, error = self.mailer.disconnect()
if success is False:
self.mon.log(self,
'Failed disconnect after send:' + str(error))
return False
else:
self.mon.log(self, 'Sent email for ' + reason)
success, error = self.mailer.disconnect()
if success is False:
self.mon.log(
self,
'Failed disconnect from email server ' + str(error))
return True
class RadioButtonShow(Show):
"""
starts at 'first-track' which can be any type of track or a show
The show has links of the form 'symbolic-name play track-ref'
An event with the symbolic-name will play the referenced track,
at the end of that track control will return to first-track
links in the tracks are ignored. Links are inherited from the show.
timeout returns to first-track
interface:
* __init__ - initlialises the show
* play - selects the first track to play (first-track)
* input_pressed, - receives user events passes them to a Shower/Player if a track is playing,
otherwise actions them depending on the symbolic name supplied
*exit - exits the show from another show, time of day scheduler or external
* terminate - aborts the show, used whan clsing or after errors
* track_ready_callback - called by the next track to be played to remove the previous track from display
* subshow_ready_callback - called by the subshow to get the last track of the parent show
* subshow_ended_callback - called at the start of a parent show to get the last track of the subshow
"""
def __init__(self, show_id, show_params, root, canvas, showlist, pp_dir,
pp_home, pp_profile, command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(self, show_id, show_params, root, canvas, showlist,
pp_dir, pp_home, pp_profile, command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr = ScreenDriver()
# create an instance of PathManager - only used to parse the links.
self.path = PathManager()
self.allowed_links = ('play', 'pause', 'exit', 'return', 'null',
'no-command', 'stop')
# init variables
self.links = []
self.track_timeout_timer = None
self.show_timeout_timer = None
self.next_track_signal = False
self.current_track_ref = ''
self.req_next = ''
def play(self, end_callback, show_ready_callback, parent_kickback_signal,
level, controls_list):
""" starts the hyperlink show at start-track
end_callback - function to be called when the show exits
show_ready_callback - callback to get the previous track
level is 0 when the show is top level (run from [start] or from show control)
parent_kickback_signal - not used other than it being passed to a show
"""
# need to instantiate the medialist here as in gapshow done in derived class
self.medialist = MediaList('ordered')
Show.base_play(self, end_callback, show_ready_callback,
parent_kickback_signal, level, controls_list)
self.mon.trace(self, self.show_params['show-ref'])
#parse the show and track timeouts
reason, message, self.show_timeout = Show.calculate_duration(
self, self.show_params['show-timeout'])
if reason == 'error':
self.mon.err(
self, 'Show Timeout has bad time: ' +
self.show_params['show-timeout'])
self.end(
'error',
'show timeout, bad time: ' + self.show_params['show-timeout'])
reason, message, self.track_timeout = Show.calculate_duration(
self, self.show_params['track-timeout'])
if reason == 'error':
self.mon.err(
self, 'Track Timeout has bad time: ' +
self.show_params['track-timeout'])
self.end(
'error', 'track timeout, bad time: ' +
self.show_params['track-timeout'])
# and delete eggtimer
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
self.do_first_track()
# ********************************
# Respond to external events
# ********************************
# exit received from another concurrent show
def exit(self):
self.stop_timers()
Show.base_exit(self)
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
# terminate Pi Presents
def terminate(self):
self.stop_timers()
Show.base_terminate(self)
# respond to inputs
def handle_input_event(self, symbol):
Show.base_handle_input_event(self, symbol)
# self.handle_input_event_this_show(symbol)
def handle_input_event_this_show(self, symbol):
# for radiobuttonshow the symbolic names are links to play tracks, also a limited number of in-track operations
# find the first entry in links that matches the symbol and execute its operation
# print 'radiobuttonshow ',symbol
found, link_op, link_arg = self.path.find_link(symbol, self.links)
# print 'input event',symbol,link_op
if found is True:
if link_op == 'play':
self.do_play(link_arg)
elif link_op == 'exit':
#exit the show
self.exit()
elif link_op == 'stop':
self.stop_timers()
if self.current_player is not None:
if self.current_track_ref == self.first_track_ref and self.level != 0:
# if quiescent then set signal to stop the show when track has stopped
self.user_stop_signal = True
self.current_player.input_pressed('stop')
elif link_op == 'return':
# return to the first track
if self.current_track_ref != self.first_track_ref:
self.do_play(self.first_track_ref)
# in-track operations
elif link_op == 'pause':
if self.current_player is not None:
self.current_player.input_pressed(link_op)
elif link_op in ('no-command', 'null'):
return
elif link_op[0:4] == 'omx-' or link_op[0:6] == 'mplay-' or link_op[
0:5] == 'uzbl-':
if self.current_player is not None:
self.current_player.input_pressed(link_op)
else:
self.mon.err(self, "unknown link command: " + link_op)
self.end('error', "unknown link command: " + link_op)
# *********************
# INTERNAL FUNCTIONS
# ********************
# *********************
# Show Sequencer
# *********************
def track_timeout_callback(self):
self.do_play(self.first_track_ref)
def do_play(self, track_ref):
# if track_ref != self.current_track_ref:
# cancel the show timeout when playing another track
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
# print '\n NEED NEXT TRACK'
self.next_track_signal = True
self.next_track_op = 'play'
self.next_track_arg = track_ref
if self.shower is not None:
# print 'current_shower not none so stopping',self.mon.id(self.current_shower)
self.shower.do_operation('stop')
elif self.current_player is not None:
# print 'current_player not none so stopping',self.mon.id(self.current_player), ' for' ,track_ref
self.current_player.input_pressed('stop')
else:
return
def do_first_track(self):
# get first-track from profile
self.first_track_ref = self.show_params['first-track-ref']
# find the track-ref in the medialisst
index = self.medialist.index_of_track(self.first_track_ref)
if index >= 0:
# don't use select the track as not using selected_track in radiobuttonshow
self.current_track_ref = self.first_track_ref
# start the show timer when displaying the first track
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
if self.show_timeout != 0:
self.show_timeout_timer = self.canvas.after(
self.show_timeout * 1000, self.show_timeout_stop)
# print 'do first track',self.current_track_ref
# and load it
self.start_load_show_loop(self.medialist.track(index))
else:
self.mon.err(
self, "first-track not found in medialist: " +
self.show_params['first-track-ref'])
self.end(
'error', "first track not found in medialist: " +
self.show_params['first-track-ref'])
# *********************
# Playing show or track
# *********************
def start_load_show_loop(self, selected_track):
# shuffle players
Show.base_shuffle(self)
# print '\nSHUFFLED previous is', self.mon.id(self.previous_player)
self.mon.trace(self, '')
self.display_eggtimer()
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer = None
# start timeout for the track if required
if self.current_track_ref != self.first_track_ref and self.track_timeout != 0:
self.track_timeout_timer = self.canvas.after(
self.track_timeout * 1000, self.track_timeout_callback)
# read the show links. Track links will be added by ready_callback
# needs to be done in show loop as each track adds different links to the show links
if self.show_params['disable-controls'] == 'yes':
self.links = []
else:
reason, message, self.links = self.path.parse_links(
self.show_params['links'], self.allowed_links)
if reason == 'error':
self.mon.err(self, message + " in show")
self.end('error', message + " in show")
# load the track or show
# params - track,, track loaded callback, end eshoer callback,enable_menu
Show.base_load_track_or_show(self, selected_track,
self.what_next_after_load,
self.end_shower, False)
# track has loaded so show it.
def what_next_after_load(self, status, message):
self.mon.trace(
self,
'load complete with status: ' + status + ' message: ' + message)
# print 'LOADED TRACK ',self.mon.id(self.current_player)
if self.current_player.play_state == 'load-failed':
self.req_next = 'error'
self.what_next_after_showing()
else:
if self.show_timeout_signal is True or self.terminate_signal is True or self.exit_signal is True or self.user_stop_signal is True:
# print 'after load - what next'
self.what_next_after_showing()
else:
self.mon.trace(self, '- showing track')
self.current_player.show(self.track_ready_callback,
self.finished_showing,
self.closed_after_showing)
def finished_showing(self, reason, message):
# showing has finished with 'pause at end', showing the next track will close it after next has started showing
self.mon.trace(self, ' - pause at end')
self.mon.log(
self, "pause at end of showing track with reason: " + reason +
' and message: ' + message)
self.sr.hide_click_areas(self.links)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next = 'finished-player'
# print 'finished showing ',self.mon.id(self.current_player),' from state ',self.current_player.play_state
self.what_next_after_showing()
def closed_after_showing(self, reason, message):
# showing has finished with closing of player but track instance is alive for hiding the x_content
self.mon.trace(self, '- closed after showing')
self.mon.log(
self, "Closed after showing track with reason: " + reason +
' and message: ' + message)
self.sr.hide_click_areas(self.links)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next = 'closed-player'
# print 'closed showing',self.mon.id(self.current_player),' from state ',self.current_player.play_state
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self, show_id, reason, message):
self.mon.log(
self, self.show_params['show-ref'] + ' ' + str(self.show_id) +
': Returned from shower with ' + reason + ' ' + message)
self.sr.hide_click_areas(self.links)
self.req_next = reason
Show.base_end_shower(self)
# print 'end shower - wha-next'
self.what_next_after_showing()
def what_next_after_showing(self):
self.mon.trace(self, '')
# print 'WHAT NEXT AFTER SHOWING'
# print 'current is',self.mon.id(self.current_player), ' next track signal ',self.next_track_signal
# need to terminate
if self.terminate_signal is True:
self.terminate_signal = False
# what to do when closed or unloaded
self.ending_reason = 'killed'
Show.base_close_or_unload(self)
elif self.req_next == 'error':
self.req_next = ''
# set what to do after closed or unloaded
self.ending_reason = 'error'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal = False
# what to do when closed or unloaded
self.ending_reason = 'show-timeout'
Show.base_close_or_unload(self)
# used by exit for stopping show from other shows.
elif self.exit_signal is True:
self.exit_signal = False
self.ending_reason = 'exit'
Show.base_close_or_unload(self)
# user wants to stop
elif self.user_stop_signal is True:
self.user_stop_signal = False
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# user has selected another track
elif self.next_track_signal is True:
self.next_track_signal = False
self.current_track_ref = self.next_track_arg
# print 'what next - next track signal is True so load ', self.current_track_ref
index = self.medialist.index_of_track(self.current_track_ref)
if index >= 0:
# don't use select the track as not using selected_track in radiobuttonshow
# and load it
Show.write_stats(self, 'play', self.show_params,
self.medialist.track(index))
self.start_load_show_loop(self.medialist.track(index))
else:
self.mon.err(
self, "next track not found in medialist: " +
self.current_track_ref)
self.end(
'error', "next track not found in medialist: " +
self.current_track_ref)
else:
# track ends naturally or is quit so go back to first track
# print 'what next - natural end so do first track'
self.do_first_track()
# *********************
# Interface with other shows/players to reduce black gaps
# *********************
# called just before a track is shown to remove the previous track from the screen
# and if necessary close it
def track_ready_callback(self, enable_show_background):
self.delete_eggtimer()
# print 'TRACK READY CALLBACK'
# print 'previous is',self.mon.id(self.previous_player), self.next_track_signal
#merge links from the track
if self.show_params['disable-controls'] == 'yes':
track_links = []
else:
reason, message, track_links = self.path.parse_links(
self.current_player.get_links(), self.allowed_links)
if reason == 'error':
self.mon.err(
self, message + " in track: " +
self.current_player.track_params['track-ref'])
self.req_next = 'error'
self.what_next_after_showing()
self.path.merge_links(self.links, track_links)
# enable the click-area that are in the list of links
self.sr.enable_click_areas(self.links)
Show.base_track_ready_callback(self, enable_show_background)
# callback from begining of a subshow, provide previous shower player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# End the show
# *********************
def end(self, reason, message):
self.stop_timers()
Show.base_end(self, reason, message)
def stop_timers(self):
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer = None
def __init__(self):
# gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
gc.set_debug(gc.DEBUG_UNCOLLECTABLE | gc.DEBUG_SAVEALL)
self.pipresents_issue = "1.4.4"
self.pipresents_minorissue = '1.4.4e'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height = 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y = 0 # position of top left corner
StopWatch.global_enable = False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM, self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options = command_options()
# print (self.options)
# get Pi Presents code directory
pp_dir = sys.path[0]
self.pp_dir = pp_dir
if not os.path.exists(pp_dir + "/pipresents.py"):
if self.options['manager'] is False:
tkinter.messagebox.showwarning("Pi Presents",
"Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path = pp_dir
self.mon = Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = [
'PiPresents', 'HyperlinkShow', 'RadioButtonShow', 'ArtLiveShow',
'ArtMediaShow', 'MediaShow', 'LiveShow', 'MenuShow', 'GapShow',
'Show', 'ArtShow', 'AudioPlayer', 'BrowserPlayer', 'ImagePlayer',
'MenuPlayer', 'MessagePlayer', 'VideoPlayer', 'Player',
'MediaList', 'LiveList', 'ShowList', 'PathManager',
'ControlsManager', 'ShowManager', 'TrackPluginManager',
'IOPluginManager', 'MplayerDriver', 'OMXDriver', 'UZBLDriver',
'TimeOfDay', 'ScreenDriver', 'Animate', 'OSCDriver',
'CounterManager', 'BeepsManager', 'Network', 'Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# Monitor.classes=['OSCDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched(
self, None,
"Pi Presents is starting, Version:" + self.pipresents_minorissue +
' at ' + time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log(
self,
"Pi Presents is starting, Version:" + self.pipresents_minorissue +
' at ' + time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self, "sys.path[0] - location of code: " + sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as ifile:
self.mon.log(self, '\nRaspbian: ' + ifile.read())
self.mon.log(
self,
'\n' + check_output(["omxplayer", "-v"], universal_newlines=True))
self.mon.log(
self,
'\nGPU Memory: ' + check_output(["vcgencmd", "get_mem", "gpu"],
universal_newlines=True))
if os.geteuid() == 0:
print('Do not run Pi Presents with sudo')
self.mon.log(self, 'Do not run Pi Presents with sudo')
self.mon.finish()
sys.exit(102)
if "DESKTOP_SESSION" not in os.environ:
print('Pi Presents must be run from the Desktop')
self.mon.log(self, 'Pi Presents must be run from the Desktop')
self.mon.finish()
sys.exit(102)
else:
self.mon.log(self, 'Desktop is ' + os.environ['DESKTOP_SESSION'])
# optional other classes used
self.root = None
self.ppio = None
self.tod = None
self.dm = None
self.animate = None
self.ioplugin_manager = None
self.oscdriver = None
self.osc_enabled = False
self.tod_enabled = False
self.email_enabled = False
user = os.getenv('USER')
if user is None:
tkinter.messagebox.showwarning(
"You must be logged in to run Pi Presents")
exit(102)
if user != 'pi':
self.mon.warn(self, "You must be logged as pi to use GPIO")
self.mon.log(self, 'User is: ' + user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected = False
self.network_details = False
self.interface = ''
self.ip = ''
self.unit = ''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled = False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject = '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime(
"%Y-%m-%d %H:%M")
message = time.strftime(
"%Y-%m-%d %H:%M"
) + '\nUnit: ' + self.unit + ' Profile: ' + self.options[
'profile'] + '\n ' + self.interface + '\n ' + self.ip
self.send_email('start', subject, message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path = "/pp_profiles/" + self.options['profile']
else:
self.mon.err(self, "Profile not specified in command ")
self.end('error',
'Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep + 'home' + os.sep + user + os.sep + "pp_home"
else:
home = self.options['home'] + os.sep + "pp_home"
self.mon.log(self, "pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found = False
for i in range(1, 10):
self.mon.log(self,
"Trying pp_home at: " + home + " (" + str(i) + ')')
if os.path.exists(home):
found = True
self.pp_home = home
break
time.sleep(1)
if found is True:
self.mon.log(
self,
"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self, "Failed to find pp_home directory at " + home)
self.end('error', "Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile = self.pp_home + self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self, None,
"Running profile: " + self.pp_profile_path)
self.mon.log(
self, "Found Requested profile - pp_profile directory is: " +
self.pp_profile)
else:
self.mon.err(
self, "Failed to find requested profile: " + self.pp_profile)
self.end('error',
"Failed to find requested profile: " + self.pp_profile)
self.mon.start_stats(self.options['profile'])
# initialise and read the showlist in the profile
self.showlist = ShowList()
self.showlist_file = self.pp_profile + "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self, "showlist not found at " + self.showlist_file)
self.end('error', "showlist not found at " + self.showlist_file)
# check profile and Pi Presents issues are compatible
if self.showlist.profile_version() != self.pipresents_version():
self.mon.err(
self,
"Version of showlist " + self.showlist.profile_version_string +
" is not same as Pi Presents")
self.end(
'error',
"Version of showlist " + self.showlist.profile_version_string +
" is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_start_show()
if index >= 0:
self.showlist.select(index)
self.starter_show = self.showlist.selected_show()
else:
self.mon.err(self, "Show [start] not found in showlist")
self.end('error', "Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset", "s", "off"])
call(["xset", "s", "-dpms"])
# find connected displays and create a canvas for each display
self.dm = DisplayManager()
status, message, self.root = self.dm.init(self.options,
self.handle_user_abort,
self.pp_dir)
if status != 'normal':
self.mon.err(self, message)
self.end('error', message)
self.mon.log(
self,
str(DisplayManager.num_displays) + ' Displays are connected:')
for display_id in DisplayManager.displays:
if self.dm.has_canvas(display_id):
canvas_obj = self.dm.canvas_widget(display_id)
canvas_obj.config(bg=self.starter_show['background-colour'])
name = self.dm.name_of_display(display_id)
width, height = self.dm.real_display_dimensions(display_id)
x, y = self.dm.real_display_position(display_id)
matrix, ms = self.dm.touch_matrix_for(display_id)
rotation = self.dm.real_display_orientation(display_id)
self.mon.log(
self, ' - ' + name + ' Id: ' + str(display_id) + ' ' +
str(x) + '+' + str(y) + '+' + str(width) + '*' + str(height) +
' ' + rotation)
self.mon.log(self, ' ' + ms)
status, message, driver_name = self.dm.get_driver_name(display_id)
if status == 'normal':
self.mon.log(self,
name + ': Touch Driver: ' + driver_name + '\n')
elif status == 'null':
self.mon.log(self, name + ': Touch Driver not Defined\n')
else:
self.mon.err(self, message)
# ****************************************
# INITIALISE THE TOUCHSCREEN DRIVER
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs
self.sr = ScreenDriver()
# read the screen click area config file
reason, message = self.sr.read(pp_dir, self.pp_home, self.pp_profile)
if reason == 'error':
self.end('error', 'cannot find, or error in screen.cfg')
# create click areas on the canvases, must be polygon as outline rectangles are not filled as far as find_closest goes
reason, message = self.sr.make_click_areas(self.handle_input_event)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required = False
self.reboot_required = False
self.terminate_required = False
self.exitpipresents_required = False
# initialise the Beeps Manager
self.beepsmanager = BeepsManager()
self.beepsmanager.init(self.pp_home, self.pp_profile)
# initialise the I/O plugins by importing their drivers
self.ioplugin_manager = IOPluginManager()
reason, message = self.ioplugin_manager.init(self.pp_dir,
self.pp_profile,
self.root,
self.handle_input_event,
self.pp_home)
if reason == 'error':
# self.mon.err(self,message)
self.end('error', message)
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir, self.pp_home, self.pp_profile, self.root,
200, self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id = -1
self.show_manager = ShowManager(show_id, self.showlist,
self.starter_show, self.root,
self.pp_dir, self.pp_profile,
self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.all_shows_ended_callback,
self.handle_command, self.showlist)
# Register all the shows in the showlist
reason, message = self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled = False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config' +
os.sep + 'osc.cfg'):
self.oscdriver = OSCDriver()
reason, message = self.oscdriver.init(
self.pp_profile, self.unit, self.interface, self.ip,
self.handle_command, self.handle_input_event,
self.e_osc_handle_animate)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
else:
self.osc_enabled = True
self.root.after(1000, self.oscdriver.start_server())
# initialise ToD scheduler calculating schedule for today
self.tod = TimeOfDay()
reason, message, self.tod_enabled = self.tod.init(
pp_dir, self.pp_home, self.pp_profile, self.showlist, self.root,
self.handle_command)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(
self,
'Network not connected so Time of Day scheduler may be using the internal clock'
)
# init the counter manager
self.counter_manager = CounterManager()
if self.starter_show['counters-store'] == 'yes':
store_enable = True
else:
store_enable = False
reason, message = self.counter_manager.init(
self.pp_profile + '/counters.cfg', store_enable,
self.options['loadcounters'],
self.starter_show['counters-initial'])
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# warn about start shows and scheduler
if self.starter_show['start-show'] == '' and self.tod_enabled is False:
self.mon.sched(
self, None,
"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(
self, "No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] != '' and self.tod_enabled is True:
self.mon.sched(
self, None,
"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(
self,
"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod.poll()
# start the I/O plugins input event generation
self.ioplugin_manager.start()
# start Tkinters event loop
self.root.mainloop()
class HyperlinkShow(Show):
"""
Aimed at touchscreens but can be used for any purpose where the user is required to follow hyperlinks between tracks
Profiles for media tracks (message, image, video, audio ) specify links to other tracks
In a link a symbolic name of an input is associated with a track-reference
The show begins at a special track specified in the profiile called the First Track and moves to other tracks
- when a link is executed by a input event with a specified symbolic name
- at the natural end of the track using the special pp-onend symbolic name
If using the 'call' link command PP keeps a record of the tracks it has visited so the 'return' command can go back.
Executes timeout-track if no user input is received (includes pp-onend but not repeat)
There is a another special track with Home Track. The home command returns here and the 'return n' command will not go back past here.
This was designed to allow the timeout to go back to First Track which would advertise the show.
Once the user had been enticed and clicked a link to move to Home pressing home or return would not return him to First Track
You can make the Home Track and the First Track the same track if you want.
You may want a track, if it is a video or audio track, to repeat. You can use repeat for this and it will not cancel the timeout.
Image and message tracks can have a zero duration so they never end naturally so repeat is not required.
links are of the form:
symbolic-name command [track-ref]
link commands:
call <track-ref> play track-ref and add it to the path
return - return 1 back up the path removing the track from the path, stops at home-track.
return n - return n tracks back up the path removing the track from the path, stops at home-track.
return <track-ref> return to <track-ref> removing tracks from the path
home - return to home-track removing tracks from the path
jump <track-ref-> - play track-ref forgetting the path back to home-track
goto <track-ref> - play track-ref, forget the path
repeat - repeat the track
exit - end the hyperlink show
null - inhibits the link defined in the show with the same symbolic name.
reserved symbolic names
pp-onend command - pseudo symbolic name for end of a track
interface:
* __init__ - initlialises the show
* play - selects the first track to play (first-track)
* input_pressed, - receives user events passes them to a Shower/Player if a track is playing,
otherwise actions them depending on the symbolic name supplied
* exit - stops the show from another show
* terminate - aborts the show, used whan clsing or after errors
* track_ready_callback - called by the next track to be played to remove the previous track from display
* subshow_ready_callback - called by the subshow to get the last track of the parent show
* subshow_ended_callback - called at the start of a parent show to get the last track of the subshow
"""
# *********************
# external interface
# ********************
def __init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(self,
show_id,
show_params,
root,
canvas,
showlist,
pp_dir,
pp_home,
pp_profile,
command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr=ScreenDriver()
# create a path stack and control path debugging
if self.show_params['debug-path']=='yes':
self.debug=True
else:
self.debug=False
self.path = PathManager()
self.allowed_links=('return','home','call','null','exit','goto','play','jump','repeat','pause','no-command','stop','pause-on','pause-off','mute','unmute','go')
# init variables
self.track_timeout_timer=None
self.show_timeout_timer=None
self.next_track_signal=False
self.next_track_ref=''
self.current_track_ref=''
self.current_track_type=''
self.req_next=''
def play(self,end_callback,show_ready_callback,parent_kickback_signal,level,controls_list):
""" starts the hyperlink show at start-track
end_callback - function to be called when the show exits
show_ready_callback - callback to get previous show and track
level is 0 when the show is top level (run from [start] or from show control)
parent_kickback_signal is not used passed to subshow by base class as parent_kickback_signal
"""
# need to instantiate the medialist here as in gapshow done in derived class
self.medialist=MediaList('ordered')
Show.base_play(self,end_callback,show_ready_callback, parent_kickback_signal,level,controls_list)
#dummy as it gets passed down to subshow, however it isn't actuallly used.
self.controls_list=[]
self.mon.trace(self, self.show_params['show-ref'])
# read show destinations
self.first_track_ref=self.show_params['first-track-ref']
self.home_track_ref=self.show_params['home-track-ref']
self.timeout_track_ref=self.show_params['timeout-track-ref']
#parse the show and track timeouts
reason,message,self.show_timeout=Show.calculate_duration(self,self.show_params['show-timeout'])
if reason =='error':
self.mon.err(self,'Show Timeout has bad time: '+self.show_params['show-timeout'])
self.end('error','show timeout, bad time: '+self.show_params['show-timeout'])
reason,message,self.track_timeout=Show.calculate_duration(self,self.show_params['track-timeout'])
if reason=='error':
self.mon.err(self,'Track Timeout has bad time: '+self.show_params['track-timeout'])
self.end('error','track timeout, bad time: ' +self.show_params['track-timeout'])
# and delete eggtimer
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
self.do_first_track()
# exit received from another concurrent show via ShowManager
def exit(self):
self.stop_timers()
Show.base_exit(self)
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
# kill or error
def terminate(self):
self.stop_timers()
Show.base_terminate(self)
# respond to inputs - call base_input_pressed to pass to subshow
def handle_input_event(self,symbol):
Show.base_handle_input_event(self,symbol)
def handle_input_event_this_show(self,symbol):
# does the symbol match a link, if so execute it
# some link commands do a subset of the internal operations
# find the first entry in links that matches the symbol and execute its operation
found,link_op,link_arg=self.path.find_link(symbol,self.links)
if found is True:
# cancel the show timeout when playing another track
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
if link_op == 'home':
self.decode_home()
self.stop_current_track()
elif link_op == 'return':
self.decode_return(link_arg)
self.stop_current_track()
elif link_op == 'call':
self.decode_call(link_arg)
self.stop_current_track()
elif link_op == 'goto':
self.decode_goto(link_arg)
self.stop_current_track()
elif link_op == 'jump':
self.decode_jump(link_arg)
self.stop_current_track()
elif link_op == 'repeat':
self.decode_repeat()
self.stop_current_track()
elif link_op == 'exit':
self.exit()
elif link_op == 'stop':
self.do_stop()
elif link_op in ('no-command','null'):
return
# in-track operations
elif link_op in ('pause','pause-on','pause-off','mute','unmute','go'):
if self.current_player is not None:
self.current_player.input_pressed(link_op)
elif link_op[0:4] == 'omx-' or link_op[0:6] == 'mplay-'or link_op[0:5] == 'uzbl-':
if self.current_player is not None:
self.current_player.input_pressed(link_op)
else:
self.mon.err(self,"unknown link command: "+ link_op)
self.end('error',"unknown link command: " + link_op)
def do_operation(self,operation):
if operation == 'stop':
self.do_stop()
def do_stop(self):
# print link_op,self.current_player,self.current_track_ref,self.level
#quiescent in all tracks
if self.level != 0:
# lower level so exit to level above
self.stop_timers()
self.user_stop_signal=True
if self.current_player is not None:
self.current_player.input_pressed('stop')
else:
# at top do nothing
pass
# *********************
# INTERNAL FUNCTIONS
# ********************
# *********************
# Show Sequencer
# *********************
def track_timeout_callback(self):
self.mon.trace(self, 'goto ' + self.timeout_track_ref)
self.next_track_op='goto'
self.next_track_arg=self.timeout_track_ref
self.what_next_after_showing()
def stop_current_track(self):
if self.shower is not None:
self.shower.do_operation('stop')
elif self.current_player is not None:
self.current_player.input_pressed('stop')
else:
self.what_next_after_showing()
def decode_call(self,track_ref):
if track_ref != self.current_track_ref:
self.mon.log(self, 'call: '+track_ref)
self.next_track_signal=True
self.next_track_op='call'
self.next_track_arg=track_ref
def decode_goto(self,to):
self.mon.log(self,'goto: '+to)
self.next_track_signal=True
self.next_track_op='goto'
self.next_track_arg=to
def decode_jump(self,to):
self.mon.log(self,'jump to: '+to)
self.next_track_signal=True
self.next_track_op='jump'
self.next_track_arg=to
def decode_repeat(self):
self.mon.log(self,'repeat: ')
self.next_track_signal=True
self.next_track_op='repeat'
def decode_return(self,to):
self.next_track_signal=True
if to.isdigit() or to == '':
self.mon.log(self,'hyperlink command - return by: '+to)
self.next_track_op='return-by'
if to == '':
self.next_track_arg='1'
else:
self.next_track_arg=to
else:
self.mon.log(self,'hyperlink command - return to: '+to)
self.next_track_op='return-to'
self.next_track_arg=to
def decode_home(self):
self.mon.log(self,'hyperlink command - home')
self.next_track_signal=True
self.next_track_op='home'
def do_first_track(self):
index = self.medialist.index_of_track(self.first_track_ref)
if index >=0:
self.continue_timeout=False
# don't use select the track as not using selected_track in hyperlinkshow
first_track=self.medialist.track(index)
self.current_track_ref=first_track['track-ref']
self.path.append(first_track['track-ref'])
if self.debug: print 'First Track: ' + first_track['track-ref']+self.path.pretty_path()
self.start_load_show_loop(first_track)
else:
self.mon.err(self,"first-track not found in medialist: "+ self.show_params['first-track-ref'])
self.end('error',"first track not found in medialist: "+ self.show_params['first-track-ref'])
def start_load_show_loop(self,selected_track):
# shuffle players
Show.base_shuffle(self)
self.mon.trace(self, '')
self.display_eggtimer()
# start the show timer when displaying the first track
if self.current_track_ref == self.first_track_ref:
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer=None
if self.show_timeout != 0:
self.show_timeout_timer=self.canvas.after(self.show_timeout*1000 ,self.show_timeout_stop)
# start timeout for the track if required ???? differnet to radiobuttonshow
if self.continue_timeout is False:
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer=None
if self.current_track_ref != self.first_track_ref and self.track_timeout != 0:
self.track_timeout_timer=self.canvas.after(self.track_timeout*1000,self.track_timeout_callback)
# get control bindings for this show
# needs to be done for each track as track can override the show controls
# read the show links. Track links will be added by track_ready_callback
if self.show_params['disable-controls'] == 'yes':
self.links=[]
else:
reason,message,self.links=self.path.parse_links(self.show_params['links'],self.allowed_links)
if reason == 'error':
self.mon.err(self,message + " in show")
self.end('error',message + " in show")
# load the track or show
# params - track,, track loaded callback, end eshoer callback,enable_menu
Show.base_load_track_or_show(self,selected_track,self.what_next_after_load,self.end_shower,False)
# track has loaded so show it.
def what_next_after_load(self,status,message):
self.mon.trace(self, ' - load complete with status: ' + status + ' message: ' + message)
if self.current_player.play_state == 'load-failed':
self.mon.err(self,'load failed')
self.req_next='error'
self.what_next_after_showing()
else:
if self.show_timeout_signal is True or self.terminate_signal is True or self.exit_signal is True or self.user_stop_signal is True:
self.what_next_after_showing()
else:
self.mon.trace(self, ' - showing track')
self.current_player.show(self.track_ready_callback,self.finished_showing,self.closed_after_showing)
def finished_showing(self,reason,message):
# showing has finished with 'pause at end'. Player is paused and track instance is alive for hiding the x_content
# this will happen in track_ready_callback of next track or in end?????
self.mon.trace(self, ' - pause at end')
self.mon.log(self,"pause at end of showing track with reason: "+reason+ ' and message: '+ message)
self.sr.hide_click_areas(self.links)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next='finished-player'
self.what_next_after_showing()
def closed_after_showing(self,reason,message):
# showing has finished with closing of player. Track instance is alive for hiding the x_content
# this will happen in track_ready_callback of next track or in end?????
self.mon.trace(self, ' - closed after showing')
self.mon.log(self,"Closed after showing track with reason: "+reason+ ' and message: '+ message)
self.sr.hide_click_areas(self.links)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next='closed-player'
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self,show_id,reason,message):
self.mon.log(self,self.show_params['show-ref']+ ' '+ str(self.show_id)+ ': Returned from shower with ' + reason +' ' + message)
self.sr.hide_click_areas(self.links)
if reason == 'error':
self.req_next='error'
self.what_next_after_showing()
else:
Show.base_end_shower(self)
self.next_track_signal=True
self.next_track_op='return-by'
self.next_track_arg='1'
self.what_next_after_showing()
def what_next_after_showing(self):
self.mon.trace(self, '')
# need to terminate
if self.terminate_signal is True:
self.terminate_signal=False
# what to do when closed or unloaded
self.ending_reason='killed'
Show.base_close_or_unload(self)
elif self.req_next== 'error':
self.req_next=''
# set what to do after closed or unloaded
self.ending_reason='error'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal=False
# what to do when closed or unloaded
self.ending_reason='show-timeout'
Show.base_close_or_unload(self)
# used by exit for stopping show from other shows.
elif self.exit_signal is True:
self.exit_signal=False
self.ending_reason='exit'
Show.base_close_or_unload(self)
# user wants to stop
elif self.user_stop_signal is True:
self.user_stop_signal=False
self.ending_reason='user-stop'
Show.base_close_or_unload(self)
# user has selected another track
elif self.next_track_signal is True:
self.next_track_signal=False
self.continue_timeout=False
# home
if self.next_track_op in ('home'):
# back to 1 before home
back_ref=self.path.back_to(self.home_track_ref)
if back_ref == '':
self.mon.err(self,"home - home track not in path: "+self.home_track_ref)
self.end('error',"home - home track not in path: "+self.home_track_ref)
# play home
self.next_track_ref=self.home_track_ref
self.path.append(self.next_track_ref)
if self.debug: print 'Executed Home ' + self.path.pretty_path()
# return-by
elif self.next_track_op in ('return-by'):
if self.current_track_ref != self.home_track_ref:
# back n stopping at home
# back one more and return it
back_ref=self.path.back_by(self.home_track_ref,self.next_track_arg)
# use returned track
self.next_track_ref=back_ref
self.path.append(self.next_track_ref)
if self.debug: print 'Executed Return By' + self.next_track_arg + self.path.pretty_path()
# repeat is return by 1
elif self.next_track_op in ('repeat'):
# print 'current', self.current_track_ref
# print 'home', self.home_track_ref
self.path.pop_for_sibling()
self.next_track_ref=self.current_track_ref
self.path.append(self.current_track_ref)
self.continue_timeout=True
if self.debug: print 'Executed Repeat ' + self.path.pretty_path()
# return-to
elif self.next_track_op in ('return-to'):
# back to one before return-to track
back_ref=self.path.back_to(self.next_track_arg)
if back_ref == '':
self.mon.err(self,"return-to - track not in path: "+self.next_track_arg)
self.end('error',"return-to - track not in path: "+self.next_track_arg)
# and append the return to track
self.next_track_ref=self.next_track_arg
self.path.append(self.next_track_ref)
if self.debug: print 'Executed Return To' + self.next_track_arg + self.path.pretty_path()
# call
elif self.next_track_op in ('call'):
# append the required track
self.path.append(self.next_track_arg)
self.next_track_ref=self.next_track_arg
if self.debug: print 'Executed Call ' + self.next_track_arg + self.path.pretty_path()
# goto
elif self.next_track_op in ('goto'):
self.path.empty()
# add the goto track
self.next_track_ref=self.next_track_arg
self.path.append(self.next_track_arg)
if self.debug: print 'Executed Goto ' + self.next_track_arg + self.path.pretty_path()
# jump
elif self.next_track_op in ('jump'):
# back to home and remove it
back_ref=self.path.back_to(self.home_track_ref)
if back_ref == '':
self.mon.err(self,"jump - home track not in path: "+self.home_track_ref)
self.end('error',"jump - track not in path: "+self.home_track_ref)
# add back the home track without playing it
self.path.append(self.home_track_ref)
# append the jumped to track
self.next_track_ref=self.next_track_arg
self.path.append(self.next_track_ref)
if self.debug: print 'Executed Jump ' + self.next_track_arg + self.path.pretty_path()
else:
self.mon.err(self,"unaddressed what next: "+ self.next_track_op+ ' '+self.next_track_arg)
self.end('error',"unaddressed what next: " + self.next_track_op+ ' '+self.next_track_arg)
self.current_track_ref=self.next_track_ref
index = self.medialist.index_of_track(self.next_track_ref)
if index >=0:
Show.write_stats(self,self.next_track_op,self.show_params,self.medialist.track(index))
# don't use select the track as not using selected_track in hyperlinkshow
self.start_load_show_loop(self.medialist.track(index))
else:
self.mon.err(self,"next-track not found in medialist: "+ self.next_track_ref)
self.end('error',"next track not found in medialist: "+ self.next_track_ref)
else:
# track ends naturally look to see if there is a pp-onend link
found,link_op,link_arg=self.path.find_link('pp-onend',self.links)
if found is True:
if link_op=='exit':
self.user_stop_signal=True
self.current_player.input_pressed('stop')
self.what_next_after_showing()
elif link_op == 'home':
self.decode_home()
self.what_next_after_showing()
elif link_op == 'return':
self.decode_return(link_arg)
self.what_next_after_showing()
elif link_op == 'call':
self.decode_call(link_arg)
self.what_next_after_showing()
elif link_op == 'goto':
self.decode_goto(link_arg)
self.what_next_after_showing()
elif link_op == 'jump':
self.decode_jump(link_arg)
self.what_next_after_showing()
elif link_op == 'repeat':
self.decode_repeat()
self.what_next_after_showing()
else:
self.mon.err(self,"unknown link command for pp_onend: "+ link_op)
self.end('error',"unkown link command for pp-onend: "+ link_op)
else:
if self.show_params['disable-controls']!='yes':
self.mon.err(self,"pp-onend for this track not found: "+ link_op)
self.end('error',"pp-onend for this track not found: "+ link_op)
## else:
## # returning from subshow or a track that does not have pp-onend
## self.next_track_op='return-by'
## self,next_track_arg='1'
## print 'subshow finishes or no on-end'
## self.what_next_after_showing()
def track_ready_callback(self,enable_show_background):
# called from a Player when ready to play, merge the links from the track with those from the show
# and then enable the click areas
self.delete_eggtimer()
if self.show_params['disable-controls'] == 'yes':
track_links=[]
else:
links_text=self.current_player.get_links()
reason,message,track_links=self.path.parse_links(links_text,self.allowed_links)
if reason == 'error':
self.mon.err(self,message + " in track: "+ self.current_player.track_params['track-ref'])
self.req_next='error'
self.what_next_after_showing()
self.path.merge_links(self.links,track_links)
# enable the click-area that are in the list of links
self.sr.enable_click_areas(self.links)
Show.base_track_ready_callback(self,enable_show_background)
# callback from begining of a subshow, provide previous shower and player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# End the show
# *********************
# finish the player for killing, error or normally
# this may be called directly sub/child shows or players are not running
# if they might be running then need to call terminate.
def end(self,reason,message):
self.mon.log(self,"Ending hyperlinkshow: "+ self.show_params['show-ref'])
self.stop_timers()
Show.base_end(self,reason,message)
def stop_timers(self):
pass
class PiPresents:
def __init__(self):
self.pipresents_issue="1.2"
self.nonfull_window_width = 0.6 # proportion of width
self.nonfull_window_height= 0.6 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
StopWatch.global_enable=False
#****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get pi presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
tkMessageBox.showwarning("Pi Presents","Bad Application Directory")
exit()
#Initialise logging
Monitor.log_path=pp_dir
self.mon=Monitor()
self.mon.on()
if self.options['debug']==True:
Monitor.global_enable=True
else:
Monitor.global_enable=False
self.mon.log (self, "Pi Presents is starting")
self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME'))
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~'))
# optional other classes used
self.ppio=None
self.tod=None
#get profile path from -p option
if self.options['profile']<>"":
self.pp_profile_path="/pp_profiles/"+self.options['profile']
else:
self.pp_profile_path = "/pp_profiles/pp_profile"
#get directory containing pp_home from the command,
if self.options['home'] =="":
home = os.path.expanduser('~')+ os.sep+"pp_home"
else:
home = self.options['home'] + os.sep+ "pp_home"
self.mon.log(self,"pp_home directory is: " + home)
#check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
# fall back to pipresents/pp_home
self.pp_home=pp_dir+"/pp_home"
found=False
for i in range (1, 10):
self.mon.log(self,"Trying pp_home at: " + home + " (" + str(i)+')')
if os.path.exists(home):
found=True
self.pp_home=home
break
time.sleep (1)
if found==True:
self.mon.log(self,"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.log(self,"FAILED to find requested home directory, using default to display error message: " + self.pp_home)
#check profile exists, if not default to error profile inside pipresents
self.pp_profile=self.pp_home+self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.pp_profile=pp_dir+"/pp_home/pp_profiles/pp_profile"
self.mon.log(self,"FAILED to find requested profile, using default to display error message: pp_profile")
if self.options['verify']==True:
val =Validator()
if val.validate_profile(None,pp_dir,self.pp_home,self.pp_profile,self.pipresents_issue,False) == False:
tkMessageBox.showwarning("Pi Presents","Validation Failed")
exit()
# open the resources
self.rr=ResourceReader()
# read the file, done once for all the other classes to use.
if self.rr.read(pp_dir,self.pp_home,self.pp_profile)==False:
self.end('error','cannot find resources.cfg')
#initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error','showlist not found')
# check profile and Pi Presents issues are compatible
if float(self.showlist.sissue())<>float(self.pipresents_issue):
self.mon.err(self,"Version of profile " + self.showlist.sissue() + " is not same as Pi Presents, must exit")
self.end('error','wrong version of profile')
# get the 'start' show from the showlist
index = self.showlist.index_of_show('start')
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error','start show not found')
# ********************
# SET UP THE GUI
# ********************
#turn off the screenblanking and saver
if self.options['noblank']==True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg='black')
# get size of the screen
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
# set window dimensions and decorations
if self.options['fullscreen']==True:
self.root.attributes('-fullscreen', True)
os.system('unclutter &')
self.window_width=self.screen_width
self.window_height=self.screen_height
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
else:
self.window_width=int(self.screen_width*self.nonfull_window_width)
self.window_height=int(self.screen_height*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
#canvas covers the whole window
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
#define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.exit_pressed)
#setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg='black')
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
# self.canvas.pack()
self.canvas.place(x=0,y=0)
self.canvas.focus_set()
# ****************************************
# INITIALISE THE INPUT DRIVERS
# ****************************************
# looks after bindings between symbolic names and internal operations
controlsmanager=ControlsManager()
if controlsmanager.read(pp_dir,self.pp_home,self.pp_profile)==False:
self.end('error','cannot find or error in controls.cfg.cfg')
else:
controlsmanager.parse_defaults()
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs/
# use keyboard driver to bind keys to symbolic names and to set up callback
kbd=KbdDriver()
if kbd.read(pp_dir,self.pp_home,self.pp_profile)==False:
self.end('error','cannot find or error in keys.cfg')
kbd.bind_keys(self.root,self.input_pressed)
self.sr=ScreenDriver()
# read the screen click area config file
if self.sr.read(pp_dir,self.pp_home,self.pp_profile)==False:
self.end('error','cannot find screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
reason,message = self.sr.make_click_areas(self.canvas,self.input_pressed)
if reason=='error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
#kick off GPIO if enabled by command line option
if self.options['gpio']==True:
from pp_gpio import PPIO
# initialise the GPIO
self.ppio=PPIO()
# PPIO.gpio_enabled=False
if self.ppio.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,50,self.gpio_pressed)==False:
self.end('error','gpio error')
# and start polling gpio
self.ppio.poll()
#kick off the time of day scheduler
self.tod=TimeOfDay()
self.tod.init(pp_dir,self.pp_home,self.canvas,500)
self.tod.poll()
# Create list of start shows initialise them and then run them
self.run_start_shows()
#start tkinter
self.root.mainloop( )
# *********************
# RUN START SHOWS
# ********************
def run_start_shows(self):
#start show manager
show_id=-1 #start show
self.show_manager=ShowManager(show_id,self.showlist,self.starter_show,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
#first time through so empty show register and set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.all_shows_ended_callback)
#parse the start shows field and start the initial shows
start_shows_text=self.starter_show['start-show']
self.show_manager.start_initial_shows(start_shows_text)
#callback from ShowManager when all shows have ended
def all_shows_ended_callback(self,reason,message,force_shutdown):
self.mon.log(self,"All shows ended, so terminate Pi Presents")
if force_shutdown==True:
self.shutdown_required=True
self.mon.log(self,"shutdown forced by profile")
self.terminate('killed')
else:
self.end(reason,message)
# *********************
# User inputs
# ********************
#gpio callback - symbol provided by gpio
def gpio_pressed(self,index,symbol,edge):
self.mon.log(self, "GPIO Pressed: "+ symbol)
self.input_pressed(symbol,edge,'gpio')
# all input events call this callback with a symbolic name.
def input_pressed(self,symbol,edge,source):
self.mon.log(self,"input received: "+symbol)
if symbol=='pp-exit':
self.exit_pressed()
elif symbol=='pp-shutdown':
self.shutdown_pressed('delay')
elif symbol=='pp-shutdownnow':
self.shutdown_pressed('now')
else:
for show in self.show_manager.shows:
show_obj=show[ShowManager.SHOW_OBJ]
if show_obj<>None:
show_obj.input_pressed(symbol,edge,source)
# **************************************
# respond to exit inputs by terminating
# **************************************
def shutdown_pressed(self, when):
if when=='delay':
self.root.after(5000,self.on_shutdown_delay)
else:
self.shutdown_required=True
self.exit_pressed()
def on_shutdown_delay(self):
if self.ppio.shutdown_pressed():
self.shutdown_required=True
self.exit_pressed()
def exit_pressed(self):
self.mon.log(self, "kill received from user")
#terminate any running shows and players
self.mon.log(self,"kill sent to shows")
self.terminate('killed')
# kill or error
def terminate(self,reason):
needs_termination=False
for show in self.show_manager.shows:
if show[ShowManager.SHOW_OBJ]<>None:
needs_termination=True
self.mon.log(self,"Sent terminate to show "+ show[ShowManager.SHOW_REF])
show[ShowManager.SHOW_OBJ].terminate(reason)
if needs_termination==False:
self.end(reason,'terminate - no termination of lower levels required')
# ******************************
# Ending Pi Presents after all the showers and players are closed
# **************************
def end(self,reason,message):
self.mon.log(self,"Pi Presents ending with message: " + reason + ' ' + message)
if reason=='error':
self.tidy_up()
self.mon.log(self, "exiting because of error")
#close logging files
self.mon.finish()
exit()
else:
self.tidy_up()
self.mon.log(self,"no error - exiting normally")
#close logging files
self.mon.finish()
if self.shutdown_required==True:
call(['sudo', 'shutdown', '-h', '-t 5','now'])
exit()
else:
exit()
# tidy up all the peripheral bits of Pi Presents
def tidy_up(self):
#turn screen blanking back on
if self.options['noblank']==True:
call(["xset","s", "on"])
call(["xset","s", "+dpms"])
# tidy up gpio
if self.options['gpio']==True and self.ppio<>None:
self.ppio.terminate()
#tidy up time of day scheduler
if self.tod<>None:
self.tod.terminate()
# *****************************
# utilitities
# ****************************
def resource(self,section,item):
value=self.rr.get(section,item)
if value==False:
self.mon.err(self, "resource: "+section +': '+ item + " not found" )
self.terminate("error")
else:
return value
def __init__(self):
self.pipresents_issue="1.2"
self.nonfull_window_width = 0.6 # proportion of width
self.nonfull_window_height= 0.6 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
StopWatch.global_enable=False
#****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get pi presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
tkMessageBox.showwarning("Pi Presents","Bad Application Directory")
exit()
#Initialise logging
Monitor.log_path=pp_dir
self.mon=Monitor()
self.mon.on()
if self.options['debug']==True:
Monitor.global_enable=True
else:
Monitor.global_enable=False
self.mon.log (self, "Pi Presents is starting")
self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME'))
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~'))
# optional other classes used
self.ppio=None
self.tod=None
#get profile path from -p option
if self.options['profile']<>"":
self.pp_profile_path="/pp_profiles/"+self.options['profile']
else:
self.pp_profile_path = "/pp_profiles/pp_profile"
#get directory containing pp_home from the command,
if self.options['home'] =="":
home = os.path.expanduser('~')+ os.sep+"pp_home"
else:
home = self.options['home'] + os.sep+ "pp_home"
self.mon.log(self,"pp_home directory is: " + home)
#check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
# fall back to pipresents/pp_home
self.pp_home=pp_dir+"/pp_home"
found=False
for i in range (1, 10):
self.mon.log(self,"Trying pp_home at: " + home + " (" + str(i)+')')
if os.path.exists(home):
found=True
self.pp_home=home
break
time.sleep (1)
if found==True:
self.mon.log(self,"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.log(self,"FAILED to find requested home directory, using default to display error message: " + self.pp_home)
#check profile exists, if not default to error profile inside pipresents
self.pp_profile=self.pp_home+self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.pp_profile=pp_dir+"/pp_home/pp_profiles/pp_profile"
self.mon.log(self,"FAILED to find requested profile, using default to display error message: pp_profile")
if self.options['verify']==True:
val =Validator()
if val.validate_profile(None,pp_dir,self.pp_home,self.pp_profile,self.pipresents_issue,False) == False:
tkMessageBox.showwarning("Pi Presents","Validation Failed")
exit()
# open the resources
self.rr=ResourceReader()
# read the file, done once for all the other classes to use.
if self.rr.read(pp_dir,self.pp_home,self.pp_profile)==False:
self.end('error','cannot find resources.cfg')
#initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error','showlist not found')
# check profile and Pi Presents issues are compatible
if float(self.showlist.sissue())<>float(self.pipresents_issue):
self.mon.err(self,"Version of profile " + self.showlist.sissue() + " is not same as Pi Presents, must exit")
self.end('error','wrong version of profile')
# get the 'start' show from the showlist
index = self.showlist.index_of_show('start')
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error','start show not found')
# ********************
# SET UP THE GUI
# ********************
#turn off the screenblanking and saver
if self.options['noblank']==True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg='black')
# get size of the screen
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
# set window dimensions and decorations
if self.options['fullscreen']==True:
self.root.attributes('-fullscreen', True)
os.system('unclutter &')
self.window_width=self.screen_width
self.window_height=self.screen_height
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
else:
self.window_width=int(self.screen_width*self.nonfull_window_width)
self.window_height=int(self.screen_height*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
#canvas covers the whole window
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
#define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.exit_pressed)
#setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg='black')
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
# self.canvas.pack()
self.canvas.place(x=0,y=0)
self.canvas.focus_set()
# ****************************************
# INITIALISE THE INPUT DRIVERS
# ****************************************
# looks after bindings between symbolic names and internal operations
controlsmanager=ControlsManager()
if controlsmanager.read(pp_dir,self.pp_home,self.pp_profile)==False:
self.end('error','cannot find or error in controls.cfg.cfg')
else:
controlsmanager.parse_defaults()
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs/
# use keyboard driver to bind keys to symbolic names and to set up callback
kbd=KbdDriver()
if kbd.read(pp_dir,self.pp_home,self.pp_profile)==False:
self.end('error','cannot find or error in keys.cfg')
kbd.bind_keys(self.root,self.input_pressed)
self.sr=ScreenDriver()
# read the screen click area config file
if self.sr.read(pp_dir,self.pp_home,self.pp_profile)==False:
self.end('error','cannot find screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
reason,message = self.sr.make_click_areas(self.canvas,self.input_pressed)
if reason=='error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
#kick off GPIO if enabled by command line option
if self.options['gpio']==True:
from pp_gpio import PPIO
# initialise the GPIO
self.ppio=PPIO()
# PPIO.gpio_enabled=False
if self.ppio.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,50,self.gpio_pressed)==False:
self.end('error','gpio error')
# and start polling gpio
self.ppio.poll()
#kick off the time of day scheduler
self.tod=TimeOfDay()
self.tod.init(pp_dir,self.pp_home,self.canvas,500)
self.tod.poll()
# Create list of start shows initialise them and then run them
self.run_start_shows()
#start tkinter
self.root.mainloop( )
class HyperlinkShow(Show):
"""
Aimed at touchscreens but can be used for any purpose where the user is required to follow hyperlinks between tracks
Profiles for media tracks (message, image, video, audio ) specify links to other tracks
In a link a symbolic name of an input is associated with a track-reference
The show begins at a special track specified in the profiile called the First Track and moves to other tracks
- when a link is executed by a input event with a specified symbolic name
- at the natural end of the track using the special pp-onend symbolic name
If using the 'call' link command PP keeps a record of the tracks it has visited so the 'return' command can go back.
Executes timeout-track if no user input is received (includes pp-onend but not repeat)
There is a another special track with Home Track. The home command returns here and the 'return n' command will not go back past here.
This was designed to allow the timeout to go back to First Track which would advertise the show.
Once the user had been enticed and clicked a link to move to Home pressing home or return would not return him to First Track
You can make the Home Track and the First Track the same track if you want.
You may want a track, if it is a video or audio track, to repeat. You can use repeat for this and it will not cancel the timeout.
Image and message tracks can have a zero duration so they never end naturally so repeat is not required.
links are of the form:
symbolic-name command [track-ref]
link commands:
call <track-ref> play track-ref and add it to the path
return - return 1 back up the path removing the track from the path, stops at home-track.
return n - return n tracks back up the path removing the track from the path, stops at home-track.
return <track-ref> return to <track-ref> removing tracks from the path
home - return to home-track removing tracks from the path
jump <track-ref-> - play track-ref forgetting the path back to home-track
goto <track-ref> - play track-ref, forget the path
repeat - repeat the track
exit - end the hyperlink show
null - inhibits the link defined in the show with the same symbolic name.
reserved symbolic names
pp-onend command - pseudo symbolic name for end of a track
interface:
* __init__ - initlialises the show
* play - selects the first track to play (first-track)
* input_pressed, - receives user events passes them to a Shower/Player if a track is playing,
otherwise actions them depending on the symbolic name supplied
* exit - stops the show from another show
* terminate - aborts the show, used whan clsing or after errors
* track_ready_callback - called by the next track to be played to remove the previous track from display
* subshow_ready_callback - called by the subshow to get the last track of the parent show
* subshow_ended_callback - called at the start of a parent show to get the last track of the subshow
"""
# *********************
# external interface
# ********************
def __init__(self, show_id, show_params, root, canvas, showlist, pp_dir,
pp_home, pp_profile, command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(self, show_id, show_params, root, canvas, showlist,
pp_dir, pp_home, pp_profile, command_callback)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr = ScreenDriver()
# create a path stack and control path debugging
if self.show_params['debug-path'] == 'yes':
self.debug = True
else:
self.debug = False
self.path = PathManager()
self.allowed_links = ('return', 'home', 'call', 'null', 'exit', 'goto',
'play', 'jump', 'repeat', 'pause', 'no-command',
'stop')
# init variables
self.track_timeout_timer = None
self.show_timeout_timer = None
self.next_track_signal = False
self.next_track_ref = ''
self.current_track_ref = ''
self.current_track_type = ''
self.req_next = ''
def play(self, end_callback, show_ready_callback, parent_kickback_signal,
level, controls_list):
""" starts the hyperlink show at start-track
end_callback - function to be called when the show exits
show_ready_callback - callback to get previous show and track
level is 0 when the show is top level (run from [start] or from show control)
parent_kickback_signal is not used passed to subshow by base class as parent_kickback_signal
"""
# need to instantiate the medialist here as in gapshow done in derived class
self.medialist = MediaList('ordered')
Show.base_play(self, end_callback, show_ready_callback,
parent_kickback_signal, level, controls_list)
#dummy as it gets passed down to subshow, however it isn't actuallly used.
self.controls_list = []
self.mon.trace(self, self.show_params['show-ref'])
# read show destinations
self.first_track_ref = self.show_params['first-track-ref']
self.home_track_ref = self.show_params['home-track-ref']
self.timeout_track_ref = self.show_params['timeout-track-ref']
#parse the show and track timeouts
reason, message, self.show_timeout = Show.calculate_duration(
self, self.show_params['show-timeout'])
if reason == 'error':
self.mon.err(
self, 'Show Timeout has bad time: ' +
self.show_params['show-timeout'])
self.end('error', 'show timeout, bad time')
reason, message, self.track_timeout = Show.calculate_duration(
self, self.show_params['track-timeout'])
if reason == 'error':
self.mon.err(
self, 'Track Timeout has bad time: ' +
self.show_params['track-timeout'])
self.end('error', 'track timeout, bad time')
# and delete eggtimer
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
self.do_first_track()
# exit received from another concurrent show via ShowManager
def exit(self):
self.stop_timers()
Show.base_exit(self)
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
# kill or error
def terminate(self):
self.stop_timers()
Show.base_terminate(self)
# respond to inputs - call base_input_pressed to pass to subshow
def handle_input_event(self, symbol):
Show.base_handle_input_event(self, symbol)
def handle_input_event_this_show(self, symbol):
# does the symbol match a link, if so execute it
# some link commands do a subset of the internal operations
# find the first entry in links that matches the symbol and execute its operation
found, link_op, link_arg = self.path.find_link(symbol, self.links)
if found is True:
# cancel the show timeout when playing another track
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
if link_op == 'home':
self.decode_home()
self.stop_current_track()
elif link_op == 'return':
self.decode_return(link_arg)
self.stop_current_track()
elif link_op == 'call':
self.decode_call(link_arg)
self.stop_current_track()
elif link_op == 'goto':
self.decode_goto(link_arg)
self.stop_current_track()
elif link_op == 'jump':
self.decode_jump(link_arg)
self.stop_current_track()
elif link_op == 'repeat':
self.decode_repeat()
self.stop_current_track()
elif link_op == 'exit':
self.exit()
elif link_op == 'stop':
self.do_stop()
elif link_op in ('no-command', 'null'):
return
# in-track operations
elif link_op == 'pause':
if self.current_player is not None:
self.current_player.input_pressed(link_op)
elif link_op[0:4] == 'omx-' or link_op[0:6] == 'mplay-' or link_op[
0:5] == 'uzbl-':
if self.current_player is not None:
self.current_player.input_pressed(link_op)
else:
self.mon.err(self, "unknown link command: " + link_op)
self.end('error', "unknown link command")
def do_operation(self, operation):
if operation == 'stop':
self.do_stop()
def do_stop(self):
# print link_op,self.current_player,self.current_track_ref,self.level
#quiescent in all tracks
if self.level != 0:
# lower level so exit to level above
self.stop_timers()
self.user_stop_signal = True
if self.current_player is not None:
self.current_player.input_pressed('stop')
else:
# at top do nothing
pass
# *********************
# INTERNAL FUNCTIONS
# ********************
# *********************
# Show Sequencer
# *********************
def track_timeout_callback(self):
self.mon.trace(self, 'goto ' + self.timeout_track_ref)
self.next_track_op = 'goto'
self.next_track_arg = self.timeout_track_ref
self.what_next_after_showing()
def stop_current_track(self):
if self.shower is not None:
self.shower.do_operation('stop')
elif self.current_player is not None:
self.current_player.input_pressed('stop')
else:
self.what_next_after_showing()
def decode_call(self, track_ref):
if track_ref != self.current_track_ref:
self.mon.log(self, 'call: ' + track_ref)
self.next_track_signal = True
self.next_track_op = 'call'
self.next_track_arg = track_ref
def decode_goto(self, to):
self.mon.log(self, 'goto: ' + to)
self.next_track_signal = True
self.next_track_op = 'goto'
self.next_track_arg = to
def decode_jump(self, to):
self.mon.log(self, 'jump to: ' + to)
self.next_track_signal = True
self.next_track_op = 'jump'
self.next_track_arg = to
def decode_repeat(self):
self.mon.log(self, 'repeat: ')
self.next_track_signal = True
self.next_track_op = 'repeat'
def decode_return(self, to):
self.next_track_signal = True
if to.isdigit() or to == '':
self.mon.log(self, 'hyperlink command - return by: ' + to)
self.next_track_op = 'return-by'
if to == '':
self.next_track_arg = '1'
else:
self.next_track_arg = to
else:
self.mon.log(self, 'hyperlink command - return to: ' + to)
self.next_track_op = 'return-to'
self.next_track_arg = to
def decode_home(self):
self.mon.log(self, 'hyperlink command - home')
self.next_track_signal = True
self.next_track_op = 'home'
def do_first_track(self):
index = self.medialist.index_of_track(self.first_track_ref)
if index >= 0:
self.continue_timeout = False
# don't use select the track as not using selected_track in hyperlinkshow
first_track = self.medialist.track(index)
self.current_track_ref = first_track['track-ref']
self.path.append(first_track['track-ref'])
if self.debug:
print 'First Track: ' + first_track[
'track-ref'] + self.path.pretty_path()
self.start_load_show_loop(first_track)
else:
self.mon.err(
self, "first-track not found in medialist: " +
self.show_params['first-track-ref'])
self.end('error', "first track not found in medialist")
def start_load_show_loop(self, selected_track):
# shuffle players
Show.base_shuffle(self)
self.mon.trace(self, '')
self.display_eggtimer()
# start the show timer when displaying the first track
if self.current_track_ref == self.first_track_ref:
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
if self.show_timeout != 0:
self.show_timeout_timer = self.canvas.after(
self.show_timeout * 1000, self.show_timeout_stop)
# start timeout for the track if required ???? differnet to radiobuttonshow
if self.continue_timeout is False:
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer = None
if self.current_track_ref != self.first_track_ref and self.track_timeout != 0:
self.track_timeout_timer = self.canvas.after(
self.track_timeout * 1000, self.track_timeout_callback)
# get control bindings for this show
# needs to be done for each track as track can override the show controls
# read the show links. Track links will be added by track_ready_callback
if self.show_params['disable-controls'] == 'yes':
self.links = []
else:
reason, message, self.links = self.path.parse_links(
self.show_params['links'], self.allowed_links)
if reason == 'error':
self.mon.err(self, message + " in show")
self.end('error', message)
# load the track or show
# params - track,, track loaded callback, end eshoer callback,enable_menu
Show.base_load_track_or_show(self, selected_track,
self.what_next_after_load,
self.end_shower, False)
# track has loaded so show it.
def what_next_after_load(self, status, message):
self.mon.trace(
self,
' - load complete with status: ' + status + ' message: ' + message)
if self.current_player.play_state == 'load-failed':
self.mon.err(self, 'load failed')
self.req_next = 'error'
self.what_next_after_showing()
else:
if self.show_timeout_signal is True or self.terminate_signal is True or self.exit_signal is True or self.user_stop_signal is True:
self.what_next_after_showing()
else:
self.mon.trace(self, ' - showing track')
self.current_player.show(self.track_ready_callback,
self.finished_showing,
self.closed_after_showing)
def finished_showing(self, reason, message):
# showing has finished with 'pause at end'. Player is paused and track instance is alive for hiding the x_content
# this will happen in track_ready_callback of next track or in end?????
self.mon.trace(self, ' - pause at end')
self.mon.log(
self, "pause at end of showing track with reason: " + reason +
' and message: ' + message)
self.sr.hide_click_areas(self.links)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next = 'finished-player'
self.what_next_after_showing()
def closed_after_showing(self, reason, message):
# showing has finished with closing of player. Track instance is alive for hiding the x_content
# this will happen in track_ready_callback of next track or in end?????
self.mon.trace(self, ' - closed after showing')
self.mon.log(
self, "Closed after showing track with reason: " + reason +
' and message: ' + message)
self.sr.hide_click_areas(self.links)
if self.current_player.play_state == 'show-failed':
self.req_next = 'error'
else:
self.req_next = 'closed-player'
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self, show_id, reason, message):
self.mon.log(
self, self.show_params['show-ref'] + ' ' + str(self.show_id) +
': Returned from shower with ' + reason + ' ' + message)
self.sr.hide_click_areas(self.links)
if reason == 'error':
self.req_next = 'error'
self.what_next_after_showing()
else:
Show.base_end_shower(self)
self.next_track_signal = True
self.next_track_op = 'return-by'
self.next_track_arg = '1'
self.what_next_after_showing()
def what_next_after_showing(self):
self.mon.trace(self, '')
# need to terminate
if self.terminate_signal is True:
self.terminate_signal = False
# what to do when closed or unloaded
self.ending_reason = 'killed'
Show.base_close_or_unload(self)
elif self.req_next == 'error':
self.req_next = ''
# set what to do after closed or unloaded
self.ending_reason = 'error'
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal = False
# what to do when closed or unloaded
self.ending_reason = 'show-timeout'
Show.base_close_or_unload(self)
# used by exit for stopping show from other shows.
elif self.exit_signal is True:
self.exit_signal = False
self.ending_reason = 'exit'
Show.base_close_or_unload(self)
# user wants to stop
elif self.user_stop_signal is True:
self.user_stop_signal = False
self.ending_reason = 'user-stop'
Show.base_close_or_unload(self)
# user has selected another track
elif self.next_track_signal is True:
self.next_track_signal = False
self.continue_timeout = False
# home
if self.next_track_op in ('home'):
# back to 1 before home
back_ref = self.path.back_to(self.home_track_ref)
if back_ref == '':
self.mon.err(
self, "home - home track not in path: " +
self.home_track_ref)
self.end('error', "home - home track not in path")
# play home
self.next_track_ref = self.home_track_ref
self.path.append(self.next_track_ref)
if self.debug: print 'Executed Home ' + self.path.pretty_path()
# return-by
elif self.next_track_op in ('return-by'):
if self.current_track_ref != self.home_track_ref:
# back n stopping at home
# back one more and return it
back_ref = self.path.back_by(self.home_track_ref,
self.next_track_arg)
# use returned track
self.next_track_ref = back_ref
self.path.append(self.next_track_ref)
if self.debug:
print 'Executed Return By' + self.next_track_arg + self.path.pretty_path(
)
# repeat is return by 1
elif self.next_track_op in ('repeat'):
# print 'current', self.current_track_ref
# print 'home', self.home_track_ref
self.path.pop_for_sibling()
self.next_track_ref = self.current_track_ref
self.path.append(self.current_track_ref)
self.continue_timeout = True
if self.debug:
print 'Executed Repeat ' + self.path.pretty_path()
# return-to
elif self.next_track_op in ('return-to'):
# back to one before return-to track
back_ref = self.path.back_to(self.next_track_arg)
if back_ref == '':
self.mon.err(
self, "return-to - track not in path: " +
self.next_track_arg)
self.end('error', "return-to - track not in path")
# and append the return to track
self.next_track_ref = self.next_track_arg
self.path.append(self.next_track_ref)
if self.debug:
print 'Executed Return To' + self.next_track_arg + self.path.pretty_path(
)
# call
elif self.next_track_op in ('call'):
# append the required track
self.path.append(self.next_track_arg)
self.next_track_ref = self.next_track_arg
if self.debug:
print 'Executed Call ' + self.next_track_arg + self.path.pretty_path(
)
# goto
elif self.next_track_op in ('goto'):
self.path.empty()
# add the goto track
self.next_track_ref = self.next_track_arg
self.path.append(self.next_track_arg)
if self.debug:
print 'Executed Goto ' + self.next_track_arg + self.path.pretty_path(
)
# jump
elif self.next_track_op in ('jump'):
# back to home and remove it
back_ref = self.path.back_to(self.home_track_ref)
if back_ref == '':
self.mon.err(
self, "jump - home track not in path: " +
self.home_track_ref)
self.end('error', "jump - track not in path")
# add back the home track without playing it
self.path.append(self.home_track_ref)
# append the jumped to track
self.next_track_ref = self.next_track_arg
self.path.append(self.next_track_ref)
if self.debug:
'Executed Jump ' + self.next_track_arg + self.path.pretty_path(
)
else:
self.mon.err(
self, "unaddressed what next: " + self.next_track_op +
' ' + self.next_track_arg)
self.end('error', "unaddressed what next")
self.current_track_ref = self.next_track_ref
index = self.medialist.index_of_track(self.next_track_ref)
if index >= 0:
Show.write_stats(self, self.next_track_op, self.show_params,
self.medialist.track(index))
# don't use select the track as not using selected_track in hyperlinkshow
self.start_load_show_loop(self.medialist.track(index))
else:
self.mon.err(
self, "next-track not found in medialist: " +
self.next_track_ref)
self.end('error', "next track not found in medialist")
else:
# track ends naturally look to see if there is a pp-onend link
found, link_op, link_arg = self.path.find_link(
'pp-onend', self.links)
if found is True:
if link_op == 'exit':
self.user_stop_signal = True
self.current_player.input_pressed('stop')
self.what_next_after_showing()
elif link_op == 'home':
self.decode_home()
self.what_next_after_showing()
elif link_op == 'return':
self.decode_return(link_arg)
self.what_next_after_showing()
elif link_op == 'call':
self.decode_call(link_arg)
self.what_next_after_showing()
elif link_op == 'goto':
self.decode_goto(link_arg)
self.what_next_after_showing()
elif link_op == 'jump':
self.decode_jump(link_arg)
self.what_next_after_showing()
elif link_op == 'repeat':
self.decode_repeat()
self.what_next_after_showing()
else:
self.mon.err(
self, "unknown link command for pp_onend: " + link_op)
self.end('error', "unkown link command for pp-onend")
else:
if self.show_params['disable-controls'] != 'yes':
self.mon.err(
self, "pp-onend for this track not found: " + link_op)
self.end('error', "pp-onend for this track not found")
## else:
## # returning from subshow or a track that does not have pp-onend
## self.next_track_op='return-by'
## self,next_track_arg='1'
## print 'subshow finishes or no on-end'
## self.what_next_after_showing()
def track_ready_callback(self, enable_show_background):
# called from a Player when ready to play, merge the links from the track with those from the show
# and then enable the click areas
self.delete_eggtimer()
if self.show_params['disable-controls'] == 'yes':
track_links = []
else:
links_text = self.current_player.get_links()
reason, message, track_links = self.path.parse_links(
links_text, self.allowed_links)
if reason == 'error':
self.mon.err(
self, message + " in track: " +
self.current_player.track_params['track-ref'])
self.req_next = 'error'
self.what_next_after_showing()
self.path.merge_links(self.links, track_links)
# enable the click-area that are in the list of links
self.sr.enable_click_areas(self.links)
Show.base_track_ready_callback(self, enable_show_background)
# callback from begining of a subshow, provide previous shower and player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# End the show
# *********************
# finish the player for killing, error or normally
# this may be called directly sub/child shows or players are not running
# if they might be running then need to call terminate.
def end(self, reason, message):
self.mon.log(self,
"Ending hyperlinkshow: " + self.show_params['show-ref'])
self.stop_timers()
Show.base_end(self, reason, message)
def stop_timers(self):
pass
class MenuShow(Show):
def __init__(self, show_id, show_params, root, canvas, showlist, pp_dir, pp_home, pp_profile, command_callback):
"""
show_id - index of the top level show caling this (for debug only)
show_params - dictionary section for the menu
canvas - the canvas that the menu is to be written on
showlist - the showlist
pp_dir - Pi Presents directory
pp_home - Pi presents data_home directory
pp_profile - Pi presents profile directory
"""
# init the common bits
Show.base__init__(
self, show_id, show_params, root, canvas, showlist, pp_dir, pp_home, pp_profile, command_callback
)
# instatiatate the screen driver - used only to access enable and hide click areas
self.sr = ScreenDriver()
self.controlsmanager = ControlsManager()
# init variables
self.show_timeout_timer = None
self.track_timeout_timer = None
self.next_track_signal = False
self.next_track = None
self.menu_index = 0
self.menu_showing = True
self.req_next = ""
def play(self, end_callback, show_ready_callback, parent_kickback_signal, level, controls_list):
""" displays the menu
end_callback - function to be called when the menu exits
show_ready_callback - callback when menu is ready to display (not used)
level is 0 when the show is top level (run from [start] or from show control)
parent_kickback_signal - not used other than it being passed to a show
"""
# need to instantiate the medialist here as not using gapshow
self.medialist = MediaList("ordered")
Show.base_play(self, end_callback, show_ready_callback, parent_kickback_signal, level, controls_list)
self.mon.trace(self, self.show_params["show-ref"])
# parse the show and track timeouts
reason, message, self.show_timeout = Show.calculate_duration(self, self.show_params["show-timeout"])
if reason == "error":
self.mon.err(self, "Show Timeout has bad time: " + self.show_params["show-timeout"])
self.end("error", "show timeout, bad time")
reason, message, self.track_timeout = Show.calculate_duration(self, self.show_params["track-timeout"])
if reason == "error":
self.mon.err(self, "Track Timeout has bad time: " + self.show_params["track-timeout"])
self.end("error", "track timeout, bad time")
# and delete eggtimer
if self.previous_shower is not None:
self.previous_shower.delete_eggtimer()
# and display the menu
self.do_menu_track()
# ********************
# respond to inputs.
# ********************
# exit received from another concurrent show
def exit(self):
self.stop_timers()
Show.base_exit(self)
# show timeout happened
def show_timeout_stop(self):
self.stop_timers()
Show.base_show_timeout_stop(self)
# terminate Pi Presents
def terminate(self):
self.stop_timers()
Show.base_terminate(self)
def handle_input_event(self, symbol):
Show.base_handle_input_event(self, symbol)
def handle_input_event_this_show(self, symbol):
# menushow has only internal operation
operation = self.base_lookup_control(symbol, self.controls_list)
self.do_operation(operation)
def do_operation(self, operation):
# service the standard inputs for this show
self.mon.trace(self, operation)
if operation == "exit":
self.exit()
elif operation == "stop":
self.stop_timers()
if self.current_player is not None:
if self.menu_showing is True and self.level != 0:
# if quiescent then set signal to stop the show when track has stopped
self.user_stop_signal = True
self.current_player.input_pressed("stop")
elif operation in ("up", "down"):
# stop show timeout
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
# and start it again
if self.show_timeout != 0:
self.show_timeout_timer = self.canvas.after(self.show_timeout * 1000, self.show_timeout_stop)
if operation == "up":
self.previous()
else:
self.next()
elif operation == "play":
self.next_track_signal = True
self.next_track = self.medialist.selected_track()
self.current_player.stop()
# cancel show timeout
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
# stop current track (the menuplayer) if running or just start the next track
if self.current_player is not None:
self.current_player.input_pressed("stop")
else:
self.what_next_after_showing()
elif operation in ("no-command", "null"):
return
elif operation == "pause":
if self.current_player is not None:
self.current_player.input_pressed(operation)
elif operation[0:4] == "omx-" or operation[0:6] == "mplay-" or operation[0:5] == "uzbl-":
if self.current_player is not None:
self.current_player.input_pressed(operation)
def next(self):
# remove highlight
if self.current_player.__class__.__name__ == "MenuPlayer":
self.current_player.highlight_menu_entry(self.menu_index, False)
self.medialist.next("ordered")
if self.menu_index == self.menu_length - 1:
self.menu_index = 0
else:
self.menu_index += 1
# and highlight the new entry
self.current_player.highlight_menu_entry(self.menu_index, True)
def previous(self):
# remove highlight
if self.current_player.__class__.__name__ == "MenuPlayer":
self.current_player.highlight_menu_entry(self.menu_index, False)
if self.menu_index == 0:
self.menu_index = self.menu_length - 1
else:
self.menu_index -= 1
self.medialist.previous("ordered")
# and highlight the new entry
self.current_player.highlight_menu_entry(self.menu_index, True)
# *********************
# Sequencing
# *********************
def track_timeout_callback(self):
self.do_operation("stop")
def do_menu_track(self):
self.menu_showing = True
self.mon.trace(self, "")
# start show timeout alarm if required
if self.show_timeout != 0:
self.show_timeout_timer = self.canvas.after(self.show_timeout * 1000, self.show_timeout_stop)
# init the index used to hiighlight the selected menu entry by menuplayer
self.menu_index = 0
index = self.medialist.index_of_track(self.show_params["menu-track-ref"])
if index == -1:
self.mon.err(self, "'menu-track' not in medialist: " + self.show_params["menu-track-ref"])
self.end("error", "menu-track not in medialist: ")
return
# make the medialist available to the menuplayer for cursor scrolling
self.show_params["medialist_obj"] = self.medialist
# load the menu track
self.start_load_show_loop(self.medialist.track(index))
# *********************
# Playing show or track loop
# *********************
def start_load_show_loop(self, selected_track):
# shuffle players
Show.base_shuffle(self)
self.mon.trace(self, "")
self.display_eggtimer()
# get control bindings for this show
# needs to be done for each track as track can override the show controls
if self.show_params["disable-controls"] == "yes":
self.controls_list = []
else:
reason, message, self.controls_list = self.controlsmanager.get_controls(self.show_params["controls"])
if reason == "error":
self.mon.err(self, message)
self.end("error", "error in controls")
return
# load the track or show
Show.base_load_track_or_show(self, selected_track, self.what_next_after_load, self.end_shower, False)
# track has loaded (menu or otherwise) so show it.
def what_next_after_load(self, status, message):
# get the calculated length of the menu for the loaded menu track
if self.current_player.__class__.__name__ == "MenuPlayer":
if self.medialist.display_length() == 0:
self.req_next = "error"
self.what_next_after_showing()
return
self.medialist.start()
self.menu_index = 0
self.menu_length = self.current_player.menu_length
self.current_player.highlight_menu_entry(self.menu_index, True)
self.mon.trace(self, " - load complete with status: " + status + " message: " + message)
if self.current_player.play_state == "load-failed":
self.req_next = "error"
self.what_next_after_showing()
else:
if (
self.show_timeout_signal is True
or self.terminate_signal is True
or self.exit_signal is True
or self.user_stop_signal is True
):
self.what_next_after_showing()
else:
self.mon.trace(self, "")
self.current_player.show(self.track_ready_callback, self.finished_showing, self.closed_after_showing)
def finished_showing(self, reason, message):
# showing has finished with 'pause at end', showing the next track will close it after next has started showing
self.mon.trace(self, "")
self.mon.log(self, "pause at end of showing track with reason: " + reason + " and message: " + message)
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == "show-failed":
self.req_next = "error"
else:
self.req_next = "finished-player"
self.what_next_after_showing()
def closed_after_showing(self, reason, message):
# showing has finished with closing of player but track instance is alive for hiding the x_content
self.mon.trace(self, "")
self.mon.log(self, "Closed after showing track with reason: " + reason + " and message: " + message)
self.sr.hide_click_areas(self.controls_list)
if self.current_player.play_state == "show-failed":
self.req_next = "error"
else:
self.req_next = "closed-player"
self.what_next_after_showing()
# subshow or child show has ended
def end_shower(self, show_id, reason, message):
self.mon.log(
self,
self.show_params["show-ref"]
+ " "
+ str(self.show_id)
+ ": Returned from shower with "
+ reason
+ " "
+ message,
)
self.sr.hide_click_areas(self.controls_list)
self.req_next = reason
Show.base_end_shower(self)
self.what_next_after_showing()
# at the end of a track check for terminations else re-display the menu
def what_next_after_showing(self):
self.mon.trace(self, "")
# cancel track timeout timer
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer = None
# need to terminate?
if self.terminate_signal is True:
self.terminate_signal = False
# set what to do when closed or unloaded
self.ending_reason = "killed"
Show.base_close_or_unload(self)
elif self.req_next == "error":
self.req_next = ""
# set what to do after closed or unloaded
self.ending_reason = "error"
Show.base_close_or_unload(self)
# show timeout
elif self.show_timeout_signal is True:
self.show_timeout_signal = False
# set what to do when closed or unloaded
self.ending_reason = "show-timeout"
Show.base_close_or_unload(self)
# used by exit for stopping show from other shows.
elif self.exit_signal is True:
self.exit_signal = False
self.ending_reason = "exit"
Show.base_close_or_unload(self)
# user wants to stop
elif self.user_stop_signal is True:
self.user_stop_signal = False
self.ending_reason = "user-stop"
Show.base_close_or_unload(self)
elif self.next_track_signal is True:
self.next_track_signal = False
self.menu_showing = False
# start timeout for the track if required
if self.track_timeout != 0:
self.track_timeout_timer = self.canvas.after(self.track_timeout * 1000, self.track_timeout_callback)
self.start_load_show_loop(self.next_track)
else:
# no stopping the show required so re-display the menu
self.do_menu_track()
# *********************
# Interface with other shows/players to reduce black gaps
# *********************
# called just before a track is shown to remove the previous track from the screen
# and if necessary close it
def track_ready_callback(self, enable_show_background):
self.delete_eggtimer()
if self.show_params["disable-controls"] != "yes":
# merge controls from the track
controls_text = self.current_player.get_links()
reason, message, track_controls = self.controlsmanager.parse_controls(controls_text)
if reason == "error":
self.mon.err(self, message + " in track: " + self.current_player.track_params["track-ref"])
self.req_next = "error"
self.what_next_after_showing()
self.controlsmanager.merge_controls(self.controls_list, track_controls)
self.sr.enable_click_areas(self.controls_list)
Show.base_track_ready_callback(self, enable_show_background)
# callback from begining of a subshow, provide previous shower player to called show
def subshow_ready_callback(self):
return Show.base_subshow_ready_callback(self)
# *********************
# Ending the show
# *********************
def end(self, reason, message):
self.stop_timers()
Show.base_end(self, reason, message)
def stop_timers(self):
if self.track_timeout_timer is not None:
self.canvas.after_cancel(self.track_timeout_timer)
self.track_timeout_timer = None
if self.show_timeout_timer is not None:
self.canvas.after_cancel(self.show_timeout_timer)
self.show_timeout_timer = None
class PiPresents(object):
def __init__(self):
gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
self.pipresents_issue="1.3"
self.pipresents_minorissue = '1.3.1i'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height= 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
self.pp_background='black'
StopWatch.global_enable=False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM,self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get Pi Presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
if self.options['manager'] is False:
tkMessageBox.showwarning("Pi Presents","Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path=pp_dir
self.mon=Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = ['PiPresents',
'HyperlinkShow','RadioButtonShow','ArtLiveShow','ArtMediaShow','MediaShow','LiveShow','MenuShow',
'GapShow','Show','ArtShow',
'AudioPlayer','BrowserPlayer','ImagePlayer','MenuPlayer','MessagePlayer','VideoPlayer','Player',
'MediaList','LiveList','ShowList',
'PathManager','ControlsManager','ShowManager','PluginManager',
'MplayerDriver','OMXDriver','UZBLDriver',
'KbdDriver','GPIODriver','TimeOfDay','ScreenDriver','Animate','OSCDriver',
'Network','Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue + ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue+ ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as file:
self.mon.log(self,'\nRaspbian: '+file.read())
self.mon.log(self,'\n'+check_output(["omxplayer", "-v"]))
self.mon.log(self,'\nGPU Memory: '+check_output(["vcgencmd", "get_mem", "gpu"]))
# optional other classes used
self.root=None
self.ppio=None
self.tod=None
self.animate=None
self.gpiodriver=None
self.oscdriver=None
self.osc_enabled=False
self.gpio_enabled=False
self.tod_enabled=False
self.email_enabled=False
if os.geteuid() == 0:
self.mon.err(self,'Do not run Pi Presents with sudo')
self.end('error','Do not run Pi Presents with sudo')
user=os.getenv('USER')
self.mon.log(self,'User is: '+ user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected=False
self.network_details=False
self.interface=''
self.ip=''
self.unit=''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled=False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject= '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime("%Y-%m-%d %H:%M")
message = time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email('start',subject,message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path="/pp_profiles/"+self.options['profile']
else:
self.mon.err(self,"Profile not specified in command ")
self.end('error','Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep+ 'home' + os.sep + user + os.sep+"pp_home"
else:
home = self.options['home'] + os.sep+ "pp_home"
self.mon.log(self,"pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found=False
for i in range (1, 10):
self.mon.log(self,"Trying pp_home at: " + home + " (" + str(i)+')')
if os.path.exists(home):
found=True
self.pp_home=home
break
time.sleep (1)
if found is True:
self.mon.log(self,"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self,"Failed to find pp_home directory at " + home)
self.end('error',"Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile=self.pp_home+self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self,"Running profile: " + self.pp_profile_path)
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.mon.err(self,"Failed to find requested profile: "+ self.pp_profile)
self.end('error',"Failed to find requested profile: "+ self.pp_profile)
self.mon.start_stats(self.options['profile'])
if self.options['verify'] is True:
val =Validator()
if val.validate_profile(None,pp_dir,self.pp_home,self.pp_profile,self.pipresents_issue,False) is False:
self.mon.err(self,"Validation Failed")
self.end('error','Validation Failed')
# initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error',"showlist not found at "+self.showlist_file)
# check profile and Pi Presents issues are compatible
if float(self.showlist.sissue()) != float(self.pipresents_issue):
self.mon.err(self,"Version of profile " + self.showlist.sissue() + " is not same as Pi Presents")
self.end('error',"Version of profile " + self.showlist.sissue() + " is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_show('start')
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error',"Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg=self.pp_background)
self.mon.log(self, 'native screen dimensions are ' + str(self.root.winfo_screenwidth()) + ' x ' + str(self.root.winfo_screenheight()) + ' pixcels')
if self.options['screensize'] =='':
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
else:
reason,message,self.screen_width,self.screen_height=self.parse_screen(self.options['screensize'])
if reason =='error':
self.mon.err(self,message)
self.end('error',message)
self.mon.log(self, 'commanded screen dimensions are ' + str(self.screen_width) + ' x ' + str(self.screen_height) + ' pixcels')
# set window dimensions and decorations
if self.options['fullscreen'] is False:
self.window_width=int(self.root.winfo_screenwidth()*self.nonfull_window_width)
self.window_height=int(self.root.winfo_screenheight()*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
else:
self.window_width=self.screen_width
self.window_height=self.screen_height
self.root.attributes('-fullscreen', True)
os.system('unclutter &')
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
# canvas cover the whole screen whatever the size of the window.
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
# define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.handle_user_abort)
# setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg=self.pp_background)
if self.options['fullscreen'] is True:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
else:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=1,
highlightcolor='yellow')
self.canvas.place(x=0,y=0)
# self.canvas.config(bg='black')
self.canvas.focus_set()
# ****************************************
# INITIALISE THE INPUT DRIVERS
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs/
# use keyboard driver to bind keys to symbolic names and to set up callback
kbd=KbdDriver()
if kbd.read(pp_dir,self.pp_home,self.pp_profile) is False:
self.end('error','cannot find, or error in keys.cfg')
kbd.bind_keys(self.root,self.handle_input_event)
self.sr=ScreenDriver()
# read the screen click area config file
reason,message = self.sr.read(pp_dir,self.pp_home,self.pp_profile)
if reason == 'error':
self.end('error','cannot find, or error in screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
# click areas are made on the Pi Presents canvas not the show canvases.
reason,message = self.sr.make_click_areas(self.canvas,self.handle_input_event)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
self.exitpipresents_required=False
# delete omxplayer dbus files
# if os.path.exists("/tmp/omxplayerdbus.{}".format(user)):
# os.remove("/tmp/omxplayerdbus.{}".format(user))
# if os.path.exists("/tmp/omxplayerdbus.{}.pid".format(user)):
# os.remove("/tmp/omxplayerdbus.{}.pid".format(user))
# kick off GPIO if enabled by command line option
self.gpio_enabled=False
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+os.sep+ 'gpio.cfg'):
# initialise the GPIO
self.gpiodriver=GPIODriver()
reason,message=self.gpiodriver.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,50,self.handle_input_event)
if reason == 'error':
self.end('error',message)
else:
self.gpio_enabled=True
# and start polling gpio
self.gpiodriver.poll()
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,200,self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id=-1
self.show_manager=ShowManager(show_id,self.showlist,self.starter_show,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.canvas,self.all_shows_ended_callback,self.handle_command,self.showlist)
# Register all the shows in the showlist
reason,message=self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled=False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+ os.sep + 'osc.cfg'):
self.oscdriver=OSCDriver()
reason,message=self.oscdriver.init(self.pp_profile,self.handle_command,self.handle_input_event,self.e_osc_handle_output_event)
if reason == 'error':
self.end('error',message)
else:
self.osc_enabled=True
self.root.after(1000,self.oscdriver.start_server())
# enable ToD scheduler if schedule exists
if os.path.exists(self.pp_profile + os.sep + 'schedule.json'):
self.tod_enabled = True
else:
self.tod_enabled=False
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(self,'Network not connected so Time of Day scheduler may be using the internal clock')
# warn about start shows and scheduler
if self.starter_show['start-show']=='' and self.tod_enabled is False:
self.mon.sched(self,"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(self,"No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] !='' and self.tod_enabled is True:
self.mon.sched(self,"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(self,"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod=TimeOfDay()
self.tod.init(pp_dir,self.pp_home,self.pp_profile,self.root,self.handle_command)
self.tod.poll()
# start Tkinters event loop
self.root.mainloop( )
def parse_screen(self,size_text):
fields=size_text.split('*')
if len(fields)!=2:
return 'error','do not understand --fullscreen comand option',0,0
elif fields[0].isdigit() is False or fields[1].isdigit() is False:
return 'error','dimensions are not positive integers in --fullscreen',0,0
else:
return 'normal','',int(fields[0]),int(fields[1])
# *********************
# RUN START SHOWS
# ********************
def run_start_shows(self):
self.mon.trace(self,'run start shows')
# parse the start shows field and start the initial shows
show_refs=self.starter_show['start-show'].split()
for show_ref in show_refs:
reason,message=self.show_manager.control_a_show(show_ref,'open')
if reason == 'error':
self.mon.err(self,message)
# *********************
# User inputs
# ********************
# handles one command provided as a line of text
def handle_command(self,command_text,source=''):
self.mon.log(self,"command received: " + command_text)
if command_text.strip()=="":
return
if command_text[0]=='/':
if self.osc_enabled is True:
self.oscdriver.send_command(command_text)
return
fields= command_text.split()
show_command=fields[0]
if len(fields)>1:
show_ref=fields[1]
else:
show_ref=''
if show_command in ('open','close'):
self.mon.sched(self, command_text + ' received from show:'+source)
if self.shutdown_required is False:
reason,message=self.show_manager.control_a_show(show_ref,show_command)
else:
return
elif show_command == 'exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to get out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
else:
reason,message= self.show_manager.exit_all_shows()
elif show_command == 'shutdownnow':
# need root.after to get out of st thread
self.root.after(1,self.e_shutdown_pressed)
return
else:
reason='error'
message = 'command not recognised: '+ show_command
if reason=='error':
self.mon.err(self,message)
return
def e_all_shows_ended_callback(self):
self.all_shows_ended_callback('normal','no shows running')
def e_shutdown_pressed(self):
self.shutdown_pressed('now')
def e_osc_handle_output_event(self,line):
#jump out of server thread
self.root.after(1, lambda arg=line: self.osc_handle_output_event(arg))
def osc_handle_output_event(self,line):
self.mon.log(self,"output event received: "+ line)
#osc sends output events as a string
reason,message,delay,name,param_type,param_values=self.animate.parse_animate_fields(line)
if reason == 'error':
self.mon.err(self,message)
self.end(reason,message)
self.handle_output_event(name,param_type,param_values,0)
def handle_output_event(self,symbol,param_type,param_values,req_time):
if self.gpio_enabled is True:
reason,message=self.gpiodriver.handle_output_event(symbol,param_type,param_values,req_time)
if reason =='error':
self.mon.err(self,message)
self.end(reason,message)
else:
self.mon.warn(self,'GPIO not enabled')
# all input events call this callback with a symbolic name.
# handle events that affect PP overall, otherwise pass to all active shows
def handle_input_event(self,symbol,source):
self.mon.log(self,"event received: "+symbol + ' from '+ source)
if symbol == 'pp-terminate':
self.handle_user_abort()
elif symbol == 'pp-shutdown':
self.shutdown_pressed('delay')
elif symbol == 'pp-shutdownnow':
# need root.after to grt out of st thread
self.root.after(1,self.e_shutdown_pressed)
return
elif symbol == 'pp-exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to grt out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
reason,message= self.show_manager.exit_all_shows()
else:
# events for shows affect the show and could cause it to exit.
for show in self.show_manager.shows:
show_obj=show[ShowManager.SHOW_OBJ]
if show_obj is not None:
show_obj.handle_input_event(symbol)
def shutdown_pressed(self, when):
if when == 'delay':
self.root.after(5000,self.on_shutdown_delay)
else:
self.shutdown_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def on_shutdown_delay(self):
# 5 second delay is up, if shutdown button still pressed then shutdown
if self.gpiodriver.shutdown_pressed() is True:
self.shutdown_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def handle_sigterm(self,signum,frame):
self.mon.log(self,'SIGTERM received - '+ str(signum))
self.terminate()
def handle_user_abort(self):
self.mon.log(self,'User abort received')
self.terminate()
def terminate(self):
self.mon.log(self, "terminate received")
needs_termination=False
for show in self.show_manager.shows:
# print show[ShowManager.SHOW_OBJ], show[ShowManager.SHOW_REF]
if show[ShowManager.SHOW_OBJ] is not None:
needs_termination=True
self.mon.log(self,"Sent terminate to show "+ show[ShowManager.SHOW_REF])
# call shows terminate method
# eventually the show will exit and after all shows have exited all_shows_callback will be executed.
show[ShowManager.SHOW_OBJ].terminate()
if needs_termination is False:
self.end('killed','killed - no termination of shows required')
# ******************************
# Ending Pi Presents after all the showers and players are closed
# **************************
# callback from ShowManager when all shows have ended
def all_shows_ended_callback(self,reason,message):
self.canvas.config(bg=self.pp_background)
if reason in ('killed','error') or self.shutdown_required is True or self.exitpipresents_required is True:
self.end(reason,message)
def end(self,reason,message):
self.mon.log(self,"Pi Presents ending with reason: " + reason)
if self.root is not None:
self.root.destroy()
self.tidy_up()
# gc.collect()
# print gc.garbage
if reason == 'killed':
if self.email_enabled is True and self.mailer.email_on_terminate is True:
subject= '[Pi Presents] ' + self.unit + ': PP Exited with reason: Terminated'
message = time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason,subject,message)
self.mon.sched(self, "Pi Presents Terminated, au revoir\n")
self.mon.log(self, "Pi Presents Terminated, au revoir")
# close logging files
self.mon.finish()
sys.exit(101)
elif reason == 'error':
if self.email_enabled is True and self.mailer.email_on_error is True:
subject= '[Pi Presents] ' + self.unit + ': PP Exited with reason: Error'
message_text = 'Error message: '+ message + '\n'+ time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason,subject,message_text)
self.mon.sched(self, "Pi Presents closing because of error, sorry\n")
self.mon.log(self, "Pi Presents closing because of error, sorry")
# close logging files
self.mon.finish()
sys.exit(102)
else:
self.mon.sched(self,"Pi Presents exiting normally, bye\n")
self.mon.log(self,"Pi Presents exiting normally, bye")
# close logging files
self.mon.finish()
if self.shutdown_required is True:
# print 'SHUTDOWN'
call(['sudo', 'shutdown', '-h', '-t 5','now'])
sys.exit(100)
def init_network(self):
timeout=int(self.options['nonetwork'])
if timeout== 0:
self.network_connected=False
self.unit=''
self.ip=''
self.interface=''
return
self.network=Network()
self.network_connected=False
# try to connect to network
self.mon.log (self, 'Waiting up to '+ str(timeout) + ' seconds for network')
success=self.network.wait_for_network(timeout)
if success is False:
self.mon.warn(self,'Failed to connect to network after ' + str(timeout) + ' seconds')
# tkMessageBox.showwarning("Pi Presents","Failed to connect to network so using fake-hwclock")
return
self.network_connected=True
self.mon.sched (self, 'Time after network check is '+ time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, 'Time after network check is '+ time.strftime("%Y-%m-%d %H:%M.%S"))
# Get web configuration
self.network_details=False
network_options_file_path=self.pp_dir+os.sep+'pp_config'+os.sep+'pp_web.cfg'
if not os.path.exists(network_options_file_path):
self.mon.warn(self,"pp_web.cfg not found at "+network_options_file_path)
return
self.mon.log(self, 'Found pp_web.cfg in ' + network_options_file_path)
self.network.read_config(network_options_file_path)
self.unit=self.network.unit
# get interface and IP details of preferred interface
self.interface,self.ip = self.network.get_preferred_ip()
if self.interface == '':
self.network_connected=False
return
self.network_details=True
self.mon.log (self, 'Network details ' + self.unit + ' ' + self.interface + ' ' +self.ip)
def init_mailer(self):
self.email_enabled=False
email_file_path = self.pp_dir+os.sep+'pp_config'+os.sep+'pp_email.cfg'
if not os.path.exists(email_file_path):
self.mon.log(self,'pp_email.cfg not found at ' + email_file_path)
return
self.mon.log(self,'Found pp_email.cfg at ' + email_file_path)
self.mailer=Mailer()
self.mailer.read_config(email_file_path)
# all Ok so can enable email if config file allows it.
if self.mailer.email_allowed is True:
self.email_enabled=True
self.mon.log (self,'Email Enabled')
## def send_email(self,reason,subject,message):
## success, error = self.mailer.connect()
## if success is False:
## self.mon.log(self, 'Failed to connect to email SMTP server ' + str(error))
## return
## else:
## success,error = self.mailer.send(subject,message)
## if success is False:
## self.mon.log(self, 'Failed to send email: ' + str(error))
## self.mailer.disconnect()
## return
## else:
## self.mon.log(self, 'Sent email for ' + reason)
## self.mailer.disconnect()
## return
def send_email(self,reason,subject,message):
if self.try_connect() is False:
return False
else:
success,error = self.mailer.send(subject,message)
if success is False:
self.mon.log(self, 'Failed to send email: ' + str(error))
success,error=self.mailer.disconnect()
if success is False:
self.mon.log(self,'Failed disconnect after send:' + str(error))
return False
else:
self.mon.log(self,'Sent email for ' + reason)
success,error=self.mailer.disconnect()
if success is False:
self.mon.log(self,'Failed disconnect from email server ' + str(error))
return True
def try_connect(self):
tries=1
while True:
success, error = self.mailer.connect()
if success is True:
return True
else:
self.mon.log(self,'Failed to connect to email SMTP server ' + str(tries) + '\n ' +str(error))
tries +=1
if tries >5:
self.mon.log(self,'Failed to connect to email SMTP server after ' + str(tries))
return False
# tidy up all the peripheral bits of Pi Presents
def tidy_up(self):
self.mon.log(self, "Tidying Up")
# turn screen blanking back on
if self.options['noblank'] is True:
call(["xset","s", "on"])
call(["xset","s", "+dpms"])
# tidy up animation and gpio
if self.animate is not None:
self.animate.terminate()
if self.gpio_enabled==True:
self.gpiodriver.terminate()
if self.osc_enabled is True:
self.oscdriver.terminate()
# tidy up time of day scheduler
if self.tod_enabled is True:
self.tod.terminate()
def __init__(self):
# gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_SAVEALL)
self.pipresents_issue="1.3.5"
self.pipresents_minorissue = '1.3.5d'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height= 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
StopWatch.global_enable=False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM,self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get Pi Presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
if self.options['manager'] is False:
tkMessageBox.showwarning("Pi Presents","Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path=pp_dir
self.mon=Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = ['PiPresents',
'HyperlinkShow','RadioButtonShow','ArtLiveShow','ArtMediaShow','MediaShow','LiveShow','MenuShow',
'GapShow','Show','ArtShow',
'AudioPlayer','BrowserPlayer','ImagePlayer','MenuPlayer','MessagePlayer','VideoPlayer','Player',
'MediaList','LiveList','ShowList',
'PathManager','ControlsManager','ShowManager','PluginManager','IOPluginManager',
'MplayerDriver','OMXDriver','UZBLDriver',
'TimeOfDay','ScreenDriver','Animate','OSCDriver','CounterManager',
'Network','Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# Monitor.classes=['OSCDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched (self,None, "Pi Presents is starting, Version:"+self.pipresents_minorissue + ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue+ ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as ifile:
self.mon.log(self,'\nRaspbian: '+ifile.read())
self.mon.log(self,'\n'+check_output(["omxplayer", "-v"]))
self.mon.log(self,'\nGPU Memory: '+check_output(["vcgencmd", "get_mem", "gpu"]))
if os.geteuid() == 0:
print 'Do not run Pi Presents with sudo'
self.mon.log(self,'Do not run Pi Presents with sudo')
self.mon.finish()
sys.exit(102)
if "DESKTOP_SESSION" not in os.environ:
print 'Pi Presents must be run from the Desktop'
self.mon.log(self,'Pi Presents must be run from the Desktop')
self.mon.finish()
sys.exit(102)
else:
self.mon.log(self,'Desktop is '+ os.environ['DESKTOP_SESSION'])
# optional other classes used
self.root=None
self.ppio=None
self.tod=None
self.animate=None
self.ioplugin_manager=None
self.oscdriver=None
self.osc_enabled=False
self.tod_enabled=False
self.email_enabled=False
user=os.getenv('USER')
if user is None:
tkMessageBox.showwarning("You must be logged in to run Pi Presents")
exit(102)
if user !='pi':
self.mon.warn(self,"You must be logged as pi to use GPIO")
self.mon.log(self,'User is: '+ user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected=False
self.network_details=False
self.interface=''
self.ip=''
self.unit=''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled=False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject= '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime("%Y-%m-%d %H:%M")
message = time.strftime("%Y-%m-%d %H:%M") + '\nUnit: ' + self.unit + ' Profile: '+ self.options['profile']+ '\n ' + self.interface + '\n ' + self.ip
self.send_email('start',subject,message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path="/pp_profiles/"+self.options['profile']
else:
self.mon.err(self,"Profile not specified in command ")
self.end('error','Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep+ 'home' + os.sep + user + os.sep+"pp_home"
else:
home = self.options['home'] + os.sep+ "pp_home"
self.mon.log(self,"pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found=False
for i in range (1, 10):
self.mon.log(self,"Trying pp_home at: " + home + " (" + str(i)+')')
if os.path.exists(home):
found=True
self.pp_home=home
break
time.sleep (1)
if found is True:
self.mon.log(self,"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self,"Failed to find pp_home directory at " + home)
self.end('error',"Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile=self.pp_home+self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self,None,"Running profile: " + self.pp_profile_path)
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.mon.err(self,"Failed to find requested profile: "+ self.pp_profile)
self.end('error',"Failed to find requested profile: "+ self.pp_profile)
self.mon.start_stats(self.options['profile'])
if self.options['verify'] is True:
self.mon.err(self,"Validation option not supported - use the editor")
self.end('error','Validation option not supported - use the editor')
# initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error',"showlist not found at "+self.showlist_file)
# check profile and Pi Presents issues are compatible
if self.showlist.profile_version() != self.pipresents_version():
self.mon.err(self,"Version of showlist " + self.showlist.profile_version_string + " is not same as Pi Presents")
self.end('error',"Version of showlist " + self.showlist.profile_version_string + " is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_start_show()
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error',"Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg=self.starter_show['background-colour'])
self.mon.log(self, 'monitor screen dimensions are ' + str(self.root.winfo_screenwidth()) + ' x ' + str(self.root.winfo_screenheight()) + ' pixels')
if self.options['screensize'] =='':
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
else:
reason,message,self.screen_width,self.screen_height=self.parse_screen(self.options['screensize'])
if reason =='error':
self.mon.err(self,message)
self.end('error',message)
self.mon.log(self, 'forced screen dimensions (--screensize) are ' + str(self.screen_width) + ' x ' + str(self.screen_height) + ' pixels')
# set window dimensions and decorations
if self.options['fullscreen'] is False:
self.window_width=int(self.root.winfo_screenwidth()*self.nonfull_window_width)
self.window_height=int(self.root.winfo_screenheight()*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
else:
self.window_width=self.screen_width
self.window_height=self.screen_height
self.root.attributes('-fullscreen', True)
os.system('unclutter &')
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
# canvas cover the whole screen whatever the size of the window.
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
# define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.handle_user_abort)
# setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg=self.starter_show['background-colour'])
if self.options['fullscreen'] is True:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
else:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=1,
highlightcolor='yellow')
self.canvas.place(x=0,y=0)
# self.canvas.config(bg='black')
self.canvas.focus_set()
# ****************************************
# INITIALISE THE TOUCHSCREEN DRIVER
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs
self.sr=ScreenDriver()
# read the screen click area config file
reason,message = self.sr.read(pp_dir,self.pp_home,self.pp_profile)
if reason == 'error':
self.end('error','cannot find, or error in screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
# click areas are made on the Pi Presents canvas not the show canvases.
reason,message = self.sr.make_click_areas(self.canvas,self.handle_input_event)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
self.reboot_required=False
self.terminate_required=False
self.exitpipresents_required=False
# initialise the I/O plugins by importing their drivers
self.ioplugin_manager=IOPluginManager()
reason,message=self.ioplugin_manager.init(self.pp_dir,self.pp_profile,self.root,self.handle_input_event)
if reason == 'error':
# self.mon.err(self,message)
self.end('error',message)
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,200,self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id=-1
self.show_manager=ShowManager(show_id,self.showlist,self.starter_show,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.canvas,self.all_shows_ended_callback,self.handle_command,self.showlist)
# Register all the shows in the showlist
reason,message=self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled=False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+ os.sep + 'osc.cfg'):
self.oscdriver=OSCDriver()
reason,message=self.oscdriver.init(self.pp_profile,
self.unit,self.interface,self.ip,
self.handle_command,self.handle_input_event,self.e_osc_handle_animate)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
else:
self.osc_enabled=True
self.root.after(1000,self.oscdriver.start_server())
# initialise ToD scheduler calculating schedule for today
self.tod=TimeOfDay()
reason,message,self.tod_enabled = self.tod.init(pp_dir,self.pp_home,self.pp_profile,self.showlist,self.root,self.handle_command)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(self,'Network not connected so Time of Day scheduler may be using the internal clock')
# init the counter manager
self.counter_manager=CounterManager()
self.counter_manager.init()
# warn about start shows and scheduler
if self.starter_show['start-show']=='' and self.tod_enabled is False:
self.mon.sched(self,None,"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(self,"No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] !='' and self.tod_enabled is True:
self.mon.sched(self,None,"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(self,"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod.poll()
# start the I/O plugins input event generation
self.ioplugin_manager.start()
# start Tkinters event loop
self.root.mainloop( )
class PiPresents(object):
def pipresents_version(self):
vitems=self.pipresents_issue.split('.')
if len(vitems)==2:
# cope with 2 digit version numbers before 1.3.2
return 1000*int(vitems[0])+100*int(vitems[1])
else:
return 1000*int(vitems[0])+100*int(vitems[1])+int(vitems[2])
def __init__(self):
# gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_SAVEALL)
self.pipresents_issue="1.3.5"
self.pipresents_minorissue = '1.3.5d'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height= 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y=0 # position of top left corner
StopWatch.global_enable=False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM,self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options=command_options()
# get Pi Presents code directory
pp_dir=sys.path[0]
self.pp_dir=pp_dir
if not os.path.exists(pp_dir+"/pipresents.py"):
if self.options['manager'] is False:
tkMessageBox.showwarning("Pi Presents","Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path=pp_dir
self.mon=Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = ['PiPresents',
'HyperlinkShow','RadioButtonShow','ArtLiveShow','ArtMediaShow','MediaShow','LiveShow','MenuShow',
'GapShow','Show','ArtShow',
'AudioPlayer','BrowserPlayer','ImagePlayer','MenuPlayer','MessagePlayer','VideoPlayer','Player',
'MediaList','LiveList','ShowList',
'PathManager','ControlsManager','ShowManager','PluginManager','IOPluginManager',
'MplayerDriver','OMXDriver','UZBLDriver',
'TimeOfDay','ScreenDriver','Animate','OSCDriver','CounterManager',
'Network','Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# Monitor.classes=['OSCDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched (self,None, "Pi Presents is starting, Version:"+self.pipresents_minorissue + ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, "Pi Presents is starting, Version:"+self.pipresents_minorissue+ ' at '+time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self,"sys.path[0] - location of code: "+sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as ifile:
self.mon.log(self,'\nRaspbian: '+ifile.read())
self.mon.log(self,'\n'+check_output(["omxplayer", "-v"]))
self.mon.log(self,'\nGPU Memory: '+check_output(["vcgencmd", "get_mem", "gpu"]))
if os.geteuid() == 0:
print 'Do not run Pi Presents with sudo'
self.mon.log(self,'Do not run Pi Presents with sudo')
self.mon.finish()
sys.exit(102)
if "DESKTOP_SESSION" not in os.environ:
print 'Pi Presents must be run from the Desktop'
self.mon.log(self,'Pi Presents must be run from the Desktop')
self.mon.finish()
sys.exit(102)
else:
self.mon.log(self,'Desktop is '+ os.environ['DESKTOP_SESSION'])
# optional other classes used
self.root=None
self.ppio=None
self.tod=None
self.animate=None
self.ioplugin_manager=None
self.oscdriver=None
self.osc_enabled=False
self.tod_enabled=False
self.email_enabled=False
user=os.getenv('USER')
if user is None:
tkMessageBox.showwarning("You must be logged in to run Pi Presents")
exit(102)
if user !='pi':
self.mon.warn(self,"You must be logged as pi to use GPIO")
self.mon.log(self,'User is: '+ user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected=False
self.network_details=False
self.interface=''
self.ip=''
self.unit=''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled=False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject= '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime("%Y-%m-%d %H:%M")
message = time.strftime("%Y-%m-%d %H:%M") + '\nUnit: ' + self.unit + ' Profile: '+ self.options['profile']+ '\n ' + self.interface + '\n ' + self.ip
self.send_email('start',subject,message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path="/pp_profiles/"+self.options['profile']
else:
self.mon.err(self,"Profile not specified in command ")
self.end('error','Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep+ 'home' + os.sep + user + os.sep+"pp_home"
else:
home = self.options['home'] + os.sep+ "pp_home"
self.mon.log(self,"pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found=False
for i in range (1, 10):
self.mon.log(self,"Trying pp_home at: " + home + " (" + str(i)+')')
if os.path.exists(home):
found=True
self.pp_home=home
break
time.sleep (1)
if found is True:
self.mon.log(self,"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self,"Failed to find pp_home directory at " + home)
self.end('error',"Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile=self.pp_home+self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self,None,"Running profile: " + self.pp_profile_path)
self.mon.log(self,"Found Requested profile - pp_profile directory is: " + self.pp_profile)
else:
self.mon.err(self,"Failed to find requested profile: "+ self.pp_profile)
self.end('error',"Failed to find requested profile: "+ self.pp_profile)
self.mon.start_stats(self.options['profile'])
if self.options['verify'] is True:
self.mon.err(self,"Validation option not supported - use the editor")
self.end('error','Validation option not supported - use the editor')
# initialise and read the showlist in the profile
self.showlist=ShowList()
self.showlist_file= self.pp_profile+ "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self,"showlist not found at "+self.showlist_file)
self.end('error',"showlist not found at "+self.showlist_file)
# check profile and Pi Presents issues are compatible
if self.showlist.profile_version() != self.pipresents_version():
self.mon.err(self,"Version of showlist " + self.showlist.profile_version_string + " is not same as Pi Presents")
self.end('error',"Version of showlist " + self.showlist.profile_version_string + " is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_start_show()
if index >=0:
self.showlist.select(index)
self.starter_show=self.showlist.selected_show()
else:
self.mon.err(self,"Show [start] not found in showlist")
self.end('error',"Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset","s", "off"])
call(["xset","s", "-dpms"])
self.root=Tk()
self.title='Pi Presents - '+ self.pp_profile
self.icon_text= 'Pi Presents'
self.root.title(self.title)
self.root.iconname(self.icon_text)
self.root.config(bg=self.starter_show['background-colour'])
self.mon.log(self, 'monitor screen dimensions are ' + str(self.root.winfo_screenwidth()) + ' x ' + str(self.root.winfo_screenheight()) + ' pixels')
if self.options['screensize'] =='':
self.screen_width = self.root.winfo_screenwidth()
self.screen_height = self.root.winfo_screenheight()
else:
reason,message,self.screen_width,self.screen_height=self.parse_screen(self.options['screensize'])
if reason =='error':
self.mon.err(self,message)
self.end('error',message)
self.mon.log(self, 'forced screen dimensions (--screensize) are ' + str(self.screen_width) + ' x ' + str(self.screen_height) + ' pixels')
# set window dimensions and decorations
if self.options['fullscreen'] is False:
self.window_width=int(self.root.winfo_screenwidth()*self.nonfull_window_width)
self.window_height=int(self.root.winfo_screenheight()*self.nonfull_window_height)
self.window_x=self.nonfull_window_x
self.window_y=self.nonfull_window_y
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
else:
self.window_width=self.screen_width
self.window_height=self.screen_height
self.root.attributes('-fullscreen', True)
os.system('unclutter &')
self.window_x=0
self.window_y=0
self.root.geometry("%dx%d%+d%+d" % (self.window_width,self.window_height,self.window_x,self.window_y))
self.root.attributes('-zoomed','1')
# canvas cover the whole screen whatever the size of the window.
self.canvas_height=self.screen_height
self.canvas_width=self.screen_width
# make sure focus is set.
self.root.focus_set()
# define response to main window closing.
self.root.protocol ("WM_DELETE_WINDOW", self.handle_user_abort)
# setup a canvas onto which will be drawn the images or text
self.canvas = Canvas(self.root, bg=self.starter_show['background-colour'])
if self.options['fullscreen'] is True:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=0)
else:
self.canvas.config(height=self.canvas_height,
width=self.canvas_width,
highlightthickness=1,
highlightcolor='yellow')
self.canvas.place(x=0,y=0)
# self.canvas.config(bg='black')
self.canvas.focus_set()
# ****************************************
# INITIALISE THE TOUCHSCREEN DRIVER
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs
self.sr=ScreenDriver()
# read the screen click area config file
reason,message = self.sr.read(pp_dir,self.pp_home,self.pp_profile)
if reason == 'error':
self.end('error','cannot find, or error in screen.cfg')
# create click areas on the canvas, must be polygon as outline rectangles are not filled as far as find_closest goes
# click areas are made on the Pi Presents canvas not the show canvases.
reason,message = self.sr.make_click_areas(self.canvas,self.handle_input_event)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required=False
self.reboot_required=False
self.terminate_required=False
self.exitpipresents_required=False
# initialise the I/O plugins by importing their drivers
self.ioplugin_manager=IOPluginManager()
reason,message=self.ioplugin_manager.init(self.pp_dir,self.pp_profile,self.root,self.handle_input_event)
if reason == 'error':
# self.mon.err(self,message)
self.end('error',message)
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir,self.pp_home,self.pp_profile,self.canvas,200,self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id=-1
self.show_manager=ShowManager(show_id,self.showlist,self.starter_show,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.canvas,self.all_shows_ended_callback,self.handle_command,self.showlist)
# Register all the shows in the showlist
reason,message=self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled=False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config'+ os.sep + 'osc.cfg'):
self.oscdriver=OSCDriver()
reason,message=self.oscdriver.init(self.pp_profile,
self.unit,self.interface,self.ip,
self.handle_command,self.handle_input_event,self.e_osc_handle_animate)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
else:
self.osc_enabled=True
self.root.after(1000,self.oscdriver.start_server())
# initialise ToD scheduler calculating schedule for today
self.tod=TimeOfDay()
reason,message,self.tod_enabled = self.tod.init(pp_dir,self.pp_home,self.pp_profile,self.showlist,self.root,self.handle_command)
if reason == 'error':
self.mon.err(self,message)
self.end('error',message)
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(self,'Network not connected so Time of Day scheduler may be using the internal clock')
# init the counter manager
self.counter_manager=CounterManager()
self.counter_manager.init()
# warn about start shows and scheduler
if self.starter_show['start-show']=='' and self.tod_enabled is False:
self.mon.sched(self,None,"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(self,"No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] !='' and self.tod_enabled is True:
self.mon.sched(self,None,"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(self,"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod.poll()
# start the I/O plugins input event generation
self.ioplugin_manager.start()
# start Tkinters event loop
self.root.mainloop( )
def parse_screen(self,size_text):
fields=size_text.split('*')
if len(fields)!=2:
return 'error','do not understand --screensize comand option',0,0
elif fields[0].isdigit() is False or fields[1].isdigit() is False:
return 'error','dimensions are not positive integers in --screensize',0,0
else:
return 'normal','',int(fields[0]),int(fields[1])
# *********************
# RUN START SHOWS
# ********************
def run_start_shows(self):
self.mon.trace(self,'run start shows')
# parse the start shows field and start the initial shows
show_refs=self.starter_show['start-show'].split()
for show_ref in show_refs:
reason,message=self.show_manager.control_a_show(show_ref,'open')
if reason == 'error':
self.mon.err(self,message)
# *********************
# User inputs
# ********************
def e_osc_handle_animate(self,line):
#jump out of server thread
self.root.after(1, lambda arg=line: self.osc_handle_animate(arg))
def osc_handle_animate(self,line):
self.mon.log(self,"animate command received: "+ line)
#osc sends output events as a string
reason,message,delay,name,param_type,param_values=self.animate.parse_animate_fields(line)
if reason == 'error':
self.mon.err(self,message)
self.end(reason,message)
self.handle_output_event(name,param_type,param_values,0)
# output events are animate commands
def handle_output_event(self,symbol,param_type,param_values,req_time):
reason,message=self.ioplugin_manager.handle_output_event(symbol,param_type,param_values,req_time)
if reason =='error':
self.mon.err(self,message)
self.end(reason,message)
# all input events call this callback providing a symbolic name.
# handle events that affect PP overall, otherwise pass to all active shows
def handle_input_event(self,symbol,source):
self.mon.log(self,"event received: "+symbol + ' from '+ source)
if symbol == 'pp-terminate':
self.handle_user_abort()
elif symbol == 'pp-shutdown':
self.mon.err(self,'pp-shutdown removed in version 1.3.3a, see Release Notes')
self.end('error','pp-shutdown removed in version 1.3.3a, see Release Notes')
elif symbol == 'pp-shutdownnow':
# need root.after to grt out of st thread
self.root.after(1,self.shutdownnow_pressed)
return
elif symbol == 'pp-exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to grt out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
reason,message= self.show_manager.exit_all_shows()
else:
# pass the input event to all registered shows
for show in self.show_manager.shows:
show_obj=show[ShowManager.SHOW_OBJ]
if show_obj is not None:
show_obj.handle_input_event(symbol)
# commands are generaed by tracks and shows
# they can open or close shows, generate input events and do special tasks
# commands also generate osc outputs to other computers
# handles one command provided as a line of text
def handle_command(self,command_text,source='',show=''):
# print 'PIPRESENTS ',command_text,'\n Source',source,'from',show
self.mon.log(self,"command received: " + command_text)
if command_text.strip()=="":
return
fields= command_text.split()
if fields[0] in ('osc','OSC'):
if self.osc_enabled is True:
status,message=self.oscdriver.parse_osc_command(fields[1:])
if status=='warn':
self.mon.warn(self,message)
if status=='error':
self.mon.err(self,message)
self.end('error',message)
return
if fields[0] =='counter':
status,message=self.counter_manager.parse_counter_command(fields[1:])
if status=='error':
self.mon.err(self,message)
self.end('error',message)
return
show_command=fields[0]
if len(fields)>1:
show_ref=fields[1]
else:
show_ref=''
if show_command in ('open','close','closeall','openexclusive'):
self.mon.sched(self, TimeOfDay.now,command_text + ' received from show:'+show)
if self.shutdown_required is False and self.terminate_required is False:
reason,message=self.show_manager.control_a_show(show_ref,show_command)
else:
return
elif show_command =='monitor':
self.handle_monitor_command(show_ref)
return
elif show_command =='cec':
self.handle_cec_command(show_ref)
return
elif show_command == 'event':
self.handle_input_event(show_ref,'Show Control')
return
elif show_command == 'exitpipresents':
self.exitpipresents_required=True
if self.show_manager.all_shows_exited() is True:
# need root.after to get out of st thread
self.root.after(1,self.e_all_shows_ended_callback)
return
else:
reason,message= self.show_manager.exit_all_shows()
elif show_command == 'shutdownnow':
# need root.after to get out of st thread
self.root.after(1,self.shutdownnow_pressed)
return
elif show_command == 'reboot':
# need root.after to get out of st thread
self.root.after(1,self.reboot_pressed)
return
else:
reason='error'
message = 'command not recognised: '+ show_command
if reason=='error':
self.mon.err(self,message)
return
def handle_monitor_command(self,command):
if command == 'on':
os.system('vcgencmd display_power 1 >/dev/null')
elif command == 'off':
os.system('vcgencmd display_power 0 >/dev/null')
def handle_cec_command(self,command):
if command == 'on':
os.system('echo "on 0" | cec-client -s')
elif command == 'standby':
os.system('echo "standby 0" | cec-client -s')
elif command == 'scan':
os.system('echo scan | cec-client -s -d 1')
# deal with differnt commands/input events
def shutdownnow_pressed(self):
self.shutdown_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def reboot_pressed(self):
self.reboot_required=True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal','no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def handle_sigterm(self,signum,fframe):
self.mon.log(self,'SIGTERM received - '+ str(signum))
self.terminate()
def handle_user_abort(self):
self.mon.log(self,'User abort received')
self.terminate()
def terminate(self):
self.mon.log(self, "terminate received")
self.terminate_required=True
needs_termination=False
for show in self.show_manager.shows:
# print show[ShowManager.SHOW_OBJ], show[ShowManager.SHOW_REF]
if show[ShowManager.SHOW_OBJ] is not None:
needs_termination=True
self.mon.log(self,"Sent terminate to show "+ show[ShowManager.SHOW_REF])
# call shows terminate method
# eventually the show will exit and after all shows have exited all_shows_callback will be executed.
show[ShowManager.SHOW_OBJ].terminate()
if needs_termination is False:
self.end('killed','killed - no termination of shows required')
# ******************************
# Ending Pi Presents after all the showers and players are closed
# **************************
def e_all_shows_ended_callback(self):
self.all_shows_ended_callback('normal','no shows running')
# callback from ShowManager when all shows have ended
def all_shows_ended_callback(self,reason,message):
self.canvas.config(bg=self.starter_show['background-colour'])
if reason in ('killed','error') or self.shutdown_required is True or self.exitpipresents_required is True or self.reboot_required is True:
self.end(reason,message)
def end(self,reason,message):
self.mon.log(self,"Pi Presents ending with reason: " + reason)
if self.root is not None:
self.root.destroy()
self.tidy_up()
if reason == 'killed':
if self.email_enabled is True and self.mailer.email_on_terminate is True:
subject= '[Pi Presents] ' + self.unit + ': PP Exited with reason: Terminated'
message = time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason,subject,message)
self.mon.sched(self, None,"Pi Presents Terminated, au revoir\n")
self.mon.log(self, "Pi Presents Terminated, au revoir")
# close logging files
self.mon.finish()
print 'Uncollectable Garbage',gc.collect()
# objgraph.show_backrefs(objgraph.by_type('Monitor'))
sys.exit(101)
elif reason == 'error':
if self.email_enabled is True and self.mailer.email_on_error is True:
subject= '[Pi Presents] ' + self.unit + ': PP Exited with reason: Error'
message_text = 'Error message: '+ message + '\n'+ time.strftime("%Y-%m-%d %H:%M") + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason,subject,message_text)
self.mon.sched(self,None, "Pi Presents closing because of error, sorry\n")
self.mon.log(self, "Pi Presents closing because of error, sorry")
# close logging files
self.mon.finish()
print 'uncollectable garbage',gc.collect()
sys.exit(102)
else:
self.mon.sched(self,None,"Pi Presents exiting normally, bye\n")
self.mon.log(self,"Pi Presents exiting normally, bye")
# close logging files
self.mon.finish()
if self.reboot_required is True:
# print 'REBOOT'
call (['sudo','reboot'])
if self.shutdown_required is True:
# print 'SHUTDOWN'
call (['sudo','shutdown','now','SHUTTING DOWN'])
print 'uncollectable garbage',gc.collect()
sys.exit(100)
# tidy up all the peripheral bits of Pi Presents
def tidy_up(self):
self.handle_monitor_command('on')
self.mon.log(self, "Tidying Up")
# turn screen blanking back on
if self.options['noblank'] is True:
call(["xset","s", "on"])
call(["xset","s", "+dpms"])
# tidy up animation
if self.animate is not None:
self.animate.terminate()
# tidy up i/o plugins
if self.ioplugin_manager != None:
self.ioplugin_manager.terminate()
if self.osc_enabled is True:
self.oscdriver.terminate()
# tidy up time of day scheduler
if self.tod_enabled is True:
self.tod.terminate()
# *******************************
# Connecting to network and email
# *******************************
def init_network(self):
timeout=int(self.options['nonetwork'])
if timeout== 0:
self.network_connected=False
self.unit=''
self.ip=''
self.interface=''
return
self.network=Network()
self.network_connected=False
# try to connect to network
self.mon.log (self, 'Waiting up to '+ str(timeout) + ' seconds for network')
success=self.network.wait_for_network(timeout)
if success is False:
self.mon.warn(self,'Failed to connect to network after ' + str(timeout) + ' seconds')
# tkMessageBox.showwarning("Pi Presents","Failed to connect to network so using fake-hwclock")
return
self.network_connected=True
self.mon.sched (self, None,'Time after network check is '+ time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log (self, 'Time after network check is '+ time.strftime("%Y-%m-%d %H:%M.%S"))
# Get web configuration
self.network_details=False
network_options_file_path=self.pp_dir+os.sep+'pp_config'+os.sep+'pp_web.cfg'
if not os.path.exists(network_options_file_path):
self.mon.warn(self,"pp_web.cfg not found at "+network_options_file_path)
return
self.mon.log(self, 'Found pp_web.cfg in ' + network_options_file_path)
self.network.read_config(network_options_file_path)
self.unit=self.network.unit
# get interface and IP details of preferred interface
self.interface,self.ip = self.network.get_preferred_ip()
if self.interface == '':
self.network_connected=False
return
self.network_details=True
self.mon.log (self, 'Network details ' + self.unit + ' ' + self.interface + ' ' +self.ip)
def init_mailer(self):
self.email_enabled=False
email_file_path = self.pp_dir+os.sep+'pp_config'+os.sep+'pp_email.cfg'
if not os.path.exists(email_file_path):
self.mon.log(self,'pp_email.cfg not found at ' + email_file_path)
return
self.mon.log(self,'Found pp_email.cfg at ' + email_file_path)
self.mailer=Mailer()
self.mailer.read_config(email_file_path)
# all Ok so can enable email if config file allows it.
if self.mailer.email_allowed is True:
self.email_enabled=True
self.mon.log (self,'Email Enabled')
def try_connect(self):
tries=1
while True:
success, error = self.mailer.connect()
if success is True:
return True
else:
self.mon.log(self,'Failed to connect to email SMTP server ' + str(tries) + '\n ' +str(error))
tries +=1
if tries >5:
self.mon.log(self,'Failed to connect to email SMTP server after ' + str(tries))
return False
def send_email(self,reason,subject,message):
if self.try_connect() is False:
return False
else:
success,error = self.mailer.send(subject,message)
if success is False:
self.mon.log(self, 'Failed to send email: ' + str(error))
success,error=self.mailer.disconnect()
if success is False:
self.mon.log(self,'Failed disconnect after send:' + str(error))
return False
else:
self.mon.log(self,'Sent email for ' + reason)
success,error=self.mailer.disconnect()
if success is False:
self.mon.log(self,'Failed disconnect from email server ' + str(error))
return True