mirror of
https://github.com/slgobinath/SafeEyes.git
synced 2024-12-24 23:50:46 +01:00
355 lines
15 KiB
Python
355 lines
15 KiB
Python
#!/usr/bin/env python
|
|
# Safe Eyes is a utility to remind you to take break frequently
|
|
# to protect your eyes from eye strain.
|
|
|
|
# Copyright (C) 2017 Gobinath
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
"""
|
|
PluginManager loads all enabled plugins and call their lifecycle methods.
|
|
A plugin must have the following directory structure:
|
|
<plugin-id>
|
|
|- config.json
|
|
|- plugin.py
|
|
|- icon.png (Optional)
|
|
|
|
The plugin.py can have following methods but all are optional:
|
|
- description()
|
|
If a custom description has to be displayed, use this function
|
|
- init(context, safeeyes_config, plugin_config)
|
|
Initialize the plugin. Will be called after loading and after every changes in configuration
|
|
- on_start()
|
|
Executes when Safe Eyes is enabled
|
|
- on_stop()
|
|
Executes when Safe Eyes is disabled
|
|
- on_exit()
|
|
Executes before Safe Eyes exits
|
|
- on_pre_break(break_obj)
|
|
Executes at the start of the prepare time for a break
|
|
- on_start_break(break_obj)
|
|
Executes when a break starts
|
|
- on_stop_break()
|
|
Executes when a break stops
|
|
- on_countdown(countdown, seconds)
|
|
Executes every second throughout a break
|
|
- update_next_break(break_obj, break_time)
|
|
Executes when the next break changes
|
|
- enable()
|
|
Executes once the plugin.py is loaded as a module
|
|
- disable()
|
|
Executes if the plugin is disabled at the runtime by the user
|
|
"""
|
|
|
|
import importlib
|
|
import logging
|
|
import os
|
|
import sys
|
|
|
|
from safeeyes import utility
|
|
from safeeyes.model import RequiredPluginException
|
|
|
|
sys.path.append(os.path.abspath(utility.SYSTEM_PLUGINS_DIR))
|
|
sys.path.append(os.path.abspath(utility.USER_PLUGINS_DIR))
|
|
|
|
HORIZONTAL_LINE_LENGTH = 64
|
|
|
|
|
|
class PluginManager:
|
|
"""
|
|
Imports the Safe Eyes plugins and calls the methods defined in those plugins.
|
|
"""
|
|
|
|
def __init__(self):
|
|
logging.info('Load all the plugins')
|
|
self.__plugins = {}
|
|
self.__plugins_on_init = []
|
|
self.__plugins_on_start = []
|
|
self.__plugins_on_stop = []
|
|
self.__plugins_on_exit = []
|
|
self.__plugins_on_pre_break = []
|
|
self.__plugins_on_start_break = []
|
|
self.__plugins_on_stop_break = []
|
|
self.__plugins_on_countdown = []
|
|
self.__plugins_update_next_break = []
|
|
self.__widget_plugins = []
|
|
self.__tray_actions_plugins = []
|
|
self.last_break = None
|
|
self.horizontal_line = '─' * HORIZONTAL_LINE_LENGTH
|
|
|
|
def init(self, context, config):
|
|
"""
|
|
Initialize all the plugins with init(context, safe_eyes_config, plugin_config) function.
|
|
"""
|
|
# Load the plugins
|
|
for plugin in config.get('plugins'):
|
|
try:
|
|
self.__load_plugin(plugin)
|
|
except RequiredPluginException as e:
|
|
raise e
|
|
except BaseException as e:
|
|
traceback_wanted = logging.getLogger().getEffectiveLevel() == logging.DEBUG
|
|
if traceback_wanted:
|
|
import traceback
|
|
traceback.print_exc()
|
|
logging.error('Error in loading the plugin %s: %s', plugin['id'], e)
|
|
continue
|
|
# Initialize the plugins
|
|
for plugin in self.__plugins_on_init:
|
|
plugin['module'].init(context, config, plugin['config'])
|
|
return True
|
|
|
|
def start(self):
|
|
"""
|
|
Execute the on_start() function of plugins.
|
|
"""
|
|
for plugin in self.__plugins_on_start:
|
|
plugin['module'].on_start()
|
|
return True
|
|
|
|
def stop(self):
|
|
"""
|
|
Execute the on_stop() function of plugins.
|
|
"""
|
|
for plugin in self.__plugins_on_stop:
|
|
plugin['module'].on_stop()
|
|
return True
|
|
|
|
def exit(self):
|
|
"""
|
|
Execute the on_exit() function of plugins.
|
|
"""
|
|
for plugin in self.__plugins_on_exit:
|
|
plugin['module'].on_exit()
|
|
return True
|
|
|
|
def pre_break(self, break_obj):
|
|
"""
|
|
Execute the on_pre_break(break_obj) function of plugins.
|
|
"""
|
|
for plugin in self.__plugins_on_pre_break:
|
|
if break_obj.plugin_enabled(plugin['id'], plugin['enabled']):
|
|
if plugin['module'].on_pre_break(break_obj):
|
|
return False
|
|
return True
|
|
|
|
def start_break(self, break_obj):
|
|
"""
|
|
Execute the start_break(break_obj) function of plugins.
|
|
"""
|
|
self.last_break = break_obj
|
|
for plugin in self.__plugins_on_start_break:
|
|
if break_obj.plugin_enabled(plugin['id'], plugin['enabled']):
|
|
if plugin['module'].on_start_break(break_obj):
|
|
return False
|
|
|
|
return True
|
|
|
|
def stop_break(self):
|
|
"""
|
|
Execute the stop_break() function of plugins.
|
|
"""
|
|
for plugin in self.__plugins_on_stop_break:
|
|
if self.last_break.plugin_enabled(plugin['id'], plugin['enabled']):
|
|
plugin['module'].on_stop_break()
|
|
|
|
def countdown(self, countdown, seconds):
|
|
"""
|
|
Execute the on_countdown(countdown, seconds) function of plugins.
|
|
"""
|
|
for plugin in self.__plugins_on_countdown:
|
|
if self.last_break.plugin_enabled(plugin['id'], plugin['enabled']):
|
|
plugin['module'].on_countdown(countdown, seconds)
|
|
|
|
def update_next_break(self, break_obj, break_time):
|
|
"""
|
|
Execute the update_next_break(break_time) function of plugins.
|
|
"""
|
|
for plugin in self.__plugins_update_next_break:
|
|
plugin['module'].update_next_break(break_obj, break_time)
|
|
return True
|
|
|
|
def get_break_screen_widgets(self, break_obj):
|
|
"""
|
|
Return the HTML widget generated by the plugins.
|
|
The widget is generated by calling the get_widget_title and get_widget_content functions of plugins.
|
|
"""
|
|
widget = ''
|
|
for plugin in self.__widget_plugins:
|
|
if break_obj.plugin_enabled(plugin['id'], plugin['enabled']):
|
|
try:
|
|
title = plugin['module'].get_widget_title(break_obj).upper().strip()
|
|
if title == '':
|
|
continue
|
|
content = plugin['module'].get_widget_content(break_obj)
|
|
if content == '':
|
|
continue
|
|
widget += '<b>{}</b>\n{}\n{}\n\n\n'.format(title, self.horizontal_line, content)
|
|
except BaseException:
|
|
continue
|
|
return widget.strip()
|
|
|
|
def get_break_screen_tray_actions(self, break_obj):
|
|
"""
|
|
Return Tray Actions.
|
|
"""
|
|
actions = []
|
|
for plugin in self.__tray_actions_plugins:
|
|
if break_obj.plugin_enabled(plugin['id'], plugin['enabled']):
|
|
action = plugin['module'].get_tray_action(break_obj)
|
|
if action:
|
|
actions.append(action)
|
|
|
|
return actions
|
|
|
|
def __load_plugin(self, plugin):
|
|
"""
|
|
Load the given plugin.
|
|
"""
|
|
plugin_enabled = plugin['enabled']
|
|
if plugin['id'] in self.__plugins and not plugin_enabled:
|
|
# A disabled plugin but that was loaded earlier
|
|
plugin_obj = self.__plugins[plugin['id']]
|
|
if plugin_obj['enabled']:
|
|
# Previously enabled but now disabled
|
|
plugin_obj['enabled'] = False
|
|
utility.remove_if_exists(self.__plugins_on_start, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_stop, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_exit, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_update_next_break, plugin_obj)
|
|
# Call the plugin.disable method if available
|
|
if utility.has_method(plugin_obj['module'], 'disable'):
|
|
plugin_obj['module'].disable()
|
|
logging.info("Successfully unloaded the plugin '%s'", plugin['id'])
|
|
|
|
if not plugin_obj['break_override_allowed']:
|
|
# Remaining methods also should be removed
|
|
utility.remove_if_exists(self.__plugins_on_init, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_pre_break, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_start_break, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_stop_break, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_countdown, plugin_obj)
|
|
utility.remove_if_exists(self.__widget_plugins, plugin_obj)
|
|
utility.remove_if_exists(self.__tray_actions_plugins, plugin_obj)
|
|
del self.__plugins[plugin['id']]
|
|
return
|
|
|
|
# Look for plugin.py
|
|
if os.path.isfile(os.path.join(utility.SYSTEM_PLUGINS_DIR, plugin['id'], 'plugin.py')):
|
|
plugin_dir = utility.SYSTEM_PLUGINS_DIR
|
|
elif os.path.isfile(os.path.join(utility.USER_PLUGINS_DIR, plugin['id'], 'plugin.py')):
|
|
plugin_dir = utility.USER_PLUGINS_DIR
|
|
else:
|
|
logging.error('plugin.py not found for the plugin: %s', plugin['id'])
|
|
return
|
|
# Look for config.json
|
|
plugin_path = os.path.join(plugin_dir, plugin['id'])
|
|
plugin_config_path = os.path.join(plugin_path, 'config.json')
|
|
if not os.path.isfile(plugin_config_path):
|
|
logging.error('config.json not found for the plugin: %s', plugin['id'])
|
|
return
|
|
plugin_config = utility.load_json(plugin_config_path)
|
|
if plugin_config is None:
|
|
return
|
|
|
|
if plugin_enabled or plugin_config.get('break_override_allowed', False):
|
|
if plugin['id'] in self.__plugins:
|
|
# The plugin is already enabled or partially loaded due to break_override_allowed
|
|
|
|
# Validate the dependencies again
|
|
if utility.check_plugin_dependencies(plugin['id'], plugin_config, plugin.get('settings', {}), plugin_path):
|
|
plugin_obj['enabled'] = False
|
|
utility.remove_if_exists(self.__plugins_on_start, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_stop, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_exit, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_update_next_break, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_init, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_pre_break, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_start_break, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_stop_break, plugin_obj)
|
|
utility.remove_if_exists(self.__plugins_on_countdown, plugin_obj)
|
|
utility.remove_if_exists(self.__widget_plugins, plugin_obj)
|
|
utility.remove_if_exists(self.__tray_actions_plugins, plugin_obj)
|
|
del self.__plugins[plugin['id']]
|
|
|
|
# Use the existing plugin object
|
|
plugin_obj = self.__plugins[plugin['id']]
|
|
|
|
# Update the config
|
|
plugin_obj['config'] = dict(plugin.get('settings', {}))
|
|
plugin_obj['config']['path'] = os.path.join(plugin_dir, plugin['id'])
|
|
|
|
if plugin_obj['enabled']:
|
|
# Already loaded completely
|
|
return
|
|
# Plugin was partially loaded due to break_override_allowed
|
|
if plugin_enabled:
|
|
# Load the rest of the methods
|
|
plugin_obj['enabled'] = True
|
|
module = plugin_obj['module']
|
|
self.__init_plugin(module, plugin_obj)
|
|
else:
|
|
# This is the first time to load the plugin
|
|
# Check for dependencies
|
|
message = utility.check_plugin_dependencies(plugin['id'], plugin_config, plugin.get('settings', {}), plugin_path)
|
|
if message:
|
|
if plugin_config.get('required_plugin', False):
|
|
raise RequiredPluginException(
|
|
plugin['id'],
|
|
plugin_config['meta']['name'],
|
|
message
|
|
)
|
|
return
|
|
|
|
# Load the plugin module
|
|
module = importlib.import_module((plugin['id'] + '.plugin'))
|
|
logging.info("Successfully loaded %s", str(module))
|
|
plugin_obj = {'id': plugin['id'], 'module': module, 'config': dict(plugin.get(
|
|
'settings', {})), 'enabled': plugin_enabled,
|
|
'break_override_allowed': plugin_config.get('break_override_allowed', False)}
|
|
# Inject the plugin directory into the config
|
|
plugin_obj['config']['path'] = os.path.join(plugin_dir, plugin['id'])
|
|
self.__plugins[plugin['id']] = plugin_obj
|
|
if utility.has_method(module, 'enable'):
|
|
module.enable()
|
|
if plugin_enabled:
|
|
self.__init_plugin(module, plugin_obj)
|
|
if utility.has_method(module, 'init', 3):
|
|
self.__plugins_on_init.append(plugin_obj)
|
|
if utility.has_method(module, 'on_pre_break', 1):
|
|
self.__plugins_on_pre_break.append(plugin_obj)
|
|
if utility.has_method(module, 'on_start_break', 1):
|
|
self.__plugins_on_start_break.append(plugin_obj)
|
|
if utility.has_method(module, 'on_stop_break', 0):
|
|
self.__plugins_on_stop_break.append(plugin_obj)
|
|
if utility.has_method(module, 'on_countdown', 2):
|
|
self.__plugins_on_countdown.append(plugin_obj)
|
|
if utility.has_method(module, 'get_widget_title', 1) and utility.has_method(module,
|
|
'get_widget_content', 1):
|
|
self.__widget_plugins.append(plugin_obj)
|
|
if utility.has_method(module, 'get_tray_action', 1):
|
|
self.__tray_actions_plugins.append(plugin_obj)
|
|
|
|
def __init_plugin(self, module, plugin_obj):
|
|
"""
|
|
Collect mandatory methods from the plugin and add them to the life cycle methods list.
|
|
"""
|
|
if utility.has_method(module, 'on_start'):
|
|
self.__plugins_on_start.append(plugin_obj)
|
|
if utility.has_method(module, 'on_stop'):
|
|
self.__plugins_on_stop.append(plugin_obj)
|
|
if utility.has_method(module, 'on_exit'):
|
|
self.__plugins_on_exit.append(plugin_obj)
|
|
if utility.has_method(module, 'update_next_break', 2):
|
|
self.__plugins_update_next_break.append(plugin_obj)
|