def __wait_until_prepare(self):
logging.info("Wait for %d seconds before the break", self.pre_break_warning_time)
# Wait for the pre break warning period
self.__wait_for(self.pre_break_warning_time)
if not self.running:
return
utility.execute_main_thread(self.__fire_start_break)
def stop_animation(self):
self.animate = False
if self.active:
utility.execute_main_thread(
lambda: self.indicator.set_icon("safeeyes_enabled"))
else:
utility.execute_main_thread(
lambda: self.indicator.set_icon("safeeyes_disabled"))
def start_animation(self):
if not self.active or not self.animate:
return
utility.execute_main_thread(lambda: self.indicator.set_icon("safeeyes_disabled"))
time.sleep(0.5)
utility.execute_main_thread(lambda: self.indicator.set_icon("safeeyes_enabled"))
if self.animate and self.active:
time.sleep(0.5)
if self.animate and self.active:
utility.start_thread(self.start_animation)
def __schedule_resume(self, time_minutes):
"""
Schedule a local timer to enable Safe Eyes after the given timeout.
"""
self.idle_condition.acquire()
self.idle_condition.wait(time_minutes * 60) # Convert to seconds
self.idle_condition.release()
with self.lock:
if not self.active:
utility.execute_main_thread(self.item_enable.activate)
def __set_next_break_info(self):
"""
A private method to be called within this class to update the next break information using self.dateTime.
"""
formatted_time = utility.format_time(self.date_time)
message = _('Next break at %s') % (formatted_time)
# Update the menu item label
utility.execute_main_thread(self.item_info.set_label, message)
# Update the tray icon label
if self.plugin_config.get('show_time_in_tray', False):
self.indicator.set_label(formatted_time, '')
else:
self.indicator.set_label('', '')
def __evaluate_arguments(args, safe_eyes):
"""
Evaluate the arguments and execute the operations.
"""
if args.about:
utility.execute_main_thread(safe_eyes.show_about)
elif args.disable:
utility.execute_main_thread(safe_eyes.disable_safeeyes)
elif args.enable:
utility.execute_main_thread(safe_eyes.enable_safeeyes)
elif args.settings:
utility.execute_main_thread(safe_eyes.show_settings)
elif args.take_break:
utility.execute_main_thread(safe_eyes.take_break)
def __start_break(self):
"""
Start the break screen.
"""
self.context['state'] = State.BREAK
break_obj = self.break_queue.get_break()
countdown = break_obj.duration
total_break_time = countdown
while countdown and self.running and not self.context['skipped'] and not self.context['postponed']:
seconds = total_break_time - countdown
self.on_count_down.fire(countdown, seconds)
time.sleep(1) # Sleep for 1 second
countdown -= 1
utility.execute_main_thread(self.__fire_stop_break)
def __scheduler_job(self):
"""
Scheduler task to execute during every interval
"""
if not self.running:
return
self.context['state'] = State.WAITING
# Convert to seconds
time_to_wait = self.break_queue.get_break().time * 60
current_time = datetime.datetime.now()
current_timestamp = current_time.timestamp()
if self.context['postponed']:
# Previous break was postponed
logging.info('Prepare for postponed break')
time_to_wait = self.postpone_duration
self.context['postponed'] = False
elif self.paused_time > -1 and self.break_queue.is_long_break():
# Safe Eyes was paused earlier and next break is long
paused_duration = int(current_timestamp - self.paused_time)
self.paused_time = -1
if paused_duration > self.break_queue.get_break().duration:
logging.info('Skip next long break due to the pause longer than break duration')
# Skip the next long break
self.break_queue.next()
if current_timestamp < self.scheduled_next_break_timestamp:
time_to_wait = round(self.scheduled_next_break_timestamp - current_timestamp)
self.scheduled_next_break_timestamp = -1
self.scheduled_next_break_time = current_time + datetime.timedelta(seconds=time_to_wait)
utility.execute_main_thread(self.__fire_on_update_next_break, self.scheduled_next_break_time)
# Wait for the pre break warning period
logging.info("Waiting for %d minutes until next break", (time_to_wait / 60))
self.__wait_for(time_to_wait)
logging.info("Pre-break waiting is over")
if not self.running:
return
utility.execute_main_thread(self.__fire_pre_break)
def __take_break(self):
"""
Show the next break screen
"""
logging.info('Take a break due to external request')
with self.lock:
if not self.running:
return
logging.info("Stop the scheduler")
# Stop the break thread
self.waiting_condition.acquire()
self.running = False
self.waiting_condition.notify_all()
self.waiting_condition.release()
time.sleep(1) # Wait for 1 sec to ensure the sceduler is dead
self.running = True
utility.execute_main_thread(self.__fire_start_break)
def __init__(self, system_locale, config):
self.active = False
self.break_screen = None
self.safe_eyes_core = None
self.config = config
self.context = {}
self.plugins_manager = None
self.settings_dialog_active = False
self.rpc_server = None
self._status = ''
# Initialize the Safe Eyes Context
self.context['version'] = SAFE_EYES_VERSION
self.context['desktop'] = utility.desktop_environment()
self.context['is_wayland'] = utility.is_wayland()
self.context['locale'] = system_locale
self.context['api'] = {}
self.context['api'][
'show_settings'] = lambda: utility.execute_main_thread(
self.show_settings)
self.context['api'][
'show_about'] = lambda: utility.execute_main_thread(self.show_about
)
self.context['api']['enable_safeeyes'] = lambda next_break_time=-1, reset_breaks=False: \
utility.execute_main_thread(self.enable_safeeyes, next_break_time, reset_breaks)
self.context['api'][
'disable_safeeyes'] = lambda status: utility.execute_main_thread(
self.disable_safeeyes, status)
self.context['api']['status'] = self.status
self.context['api']['quit'] = lambda: utility.execute_main_thread(self.
quit)
if self.config.get('persist_state'):
self.context['session'] = utility.open_session()
else:
self.context['session'] = {'plugin': {}}
self.break_screen = BreakScreen(self.context, self.on_skipped,
self.on_postponed,
utility.STYLE_SHEET_PATH)
self.break_screen.initialize(self.config)
self.plugins_manager = PluginManager()
self.safe_eyes_core = SafeEyesCore(self.context)
self.safe_eyes_core.on_pre_break += self.plugins_manager.pre_break
self.safe_eyes_core.on_start_break += self.on_start_break
self.safe_eyes_core.start_break += self.start_break
self.safe_eyes_core.on_count_down += self.countdown
self.safe_eyes_core.on_stop_break += self.stop_break
self.safe_eyes_core.on_update_next_break += self.update_next_break
self.safe_eyes_core.initialize(self.config)
self.context['api'][
'take_break'] = lambda: utility.execute_main_thread(
self.safe_eyes_core.take_break)
self.context['api']['has_breaks'] = self.safe_eyes_core.has_breaks
self.context['api']['postpone'] = self.safe_eyes_core.postpone
self.plugins_manager.init(self.context, self.config)
atexit.register(self.persist_session)
def __postpone_break(self):
self.__wait_for(self.postpone_duration)
utility.execute_main_thread(self.__fire_start_break)