Lucas Oskorep
117 lines
4.9 KiB
Python
117 lines
4.9 KiB
Python
import time, os
|
|
|
|
from . import App
|
|
from .app_state import AppState
|
|
|
|
from macropad_os.system_apps import OptionsApp, DebugApp, JsonApp
|
|
|
|
|
|
class MacropadOS(object):
|
|
def __init__(self, macropad, config, python_apps: str, json_apps: str):
|
|
print("app router")
|
|
self.macropad = macropad
|
|
self.app_index = 0
|
|
self.options = OptionsApp(macropad, config)
|
|
self.config = config
|
|
self.encoder_state = False
|
|
self.options_time = 500000000 # .5 seconds in nanoseconds
|
|
self.click_time = 0
|
|
self.debug_app = DebugApp(macropad, config, "DEBUG APP")
|
|
self.debug_app_active = self.config.debug_app_enabled()
|
|
self.python_apps_location = python_apps
|
|
self.json_apps_location = json_apps
|
|
self.apps: [App] = []
|
|
self.load_python_apps()
|
|
self.load_json_apps()
|
|
self.current_app = self.apps[self.app_index]
|
|
if self.debug_app_active:
|
|
self.apps.append(self.debug_app)
|
|
|
|
def swap_to_app(self, app):
|
|
"""
|
|
TODO: Calculate the size of the stack and the max size of hte stack and then fully close apps if need be.
|
|
:param app:
|
|
:return:
|
|
"""
|
|
print("Pausing current app")
|
|
self.current_app.pause()
|
|
print("Selecting new app")
|
|
self.current_app = app
|
|
if self.current_app._state is AppState.STOPPED:
|
|
print("Starting new app")
|
|
self.current_app.start()
|
|
if self.current_app._state is AppState.PAUSED:
|
|
print("Starting new app")
|
|
self.current_app.resume()
|
|
|
|
def load_python_apps(self):
|
|
app_classes = []
|
|
for filename in sorted(os.listdir(self.python_apps_location)):
|
|
if filename.endswith('.py') and not filename.startswith('._'):
|
|
try:
|
|
print(filename)
|
|
module = __import__(self.python_apps_location + '/' + filename[:-3])
|
|
classes = [getattr(module, a) for a in dir(module)
|
|
if isinstance(getattr(module, a), type)]
|
|
for cls in classes:
|
|
if issubclass(cls, App) and cls.__name__ != "App":
|
|
app_classes.append(cls)
|
|
print(app_classes)
|
|
except (SyntaxError, ImportError, AttributeError, KeyError, NameError, IndexError, TypeError) as err:
|
|
print("ERROR in", filename)
|
|
import traceback
|
|
traceback.print_exception(err, err, err.__traceback__)
|
|
self.apps.extend(a(self.macropad, self.config) for a in app_classes)
|
|
|
|
def load_json_apps(self):
|
|
json_apps = []
|
|
for filename in sorted(os.listdir(self.json_apps_location)):
|
|
if filename.endswith('.json'):
|
|
json_apps.append(
|
|
JsonApp(
|
|
self.macropad,
|
|
self.config,
|
|
self.json_apps_location + "/" + filename
|
|
)
|
|
)
|
|
json_apps.sort(key=lambda x: x.sort_order)
|
|
self.apps.extend(json_apps)
|
|
|
|
def start(self) -> None:
|
|
print(self.current_app)
|
|
self.current_app.start()
|
|
self.current_app.resume()
|
|
|
|
while True:
|
|
# detect if the current app is what should be running
|
|
# stop current app and start new one if not
|
|
self.current_app.loop()
|
|
# any other finite state machine logic that comes up
|
|
if self.macropad.encoder_switch_debounced.pressed and not self.encoder_state:
|
|
self.macropad.play_tone(1000, .1)
|
|
self.encoder_state = True
|
|
self.click_time = time.monotonic_ns()
|
|
|
|
elif self.macropad.encoder_switch_debounced.released and self.encoder_state:
|
|
self.encoder_state = False
|
|
if self.current_app is self.options:
|
|
print("Moving from options to the last opened app.")
|
|
if self.debug_app_active != self.config.debug_app_enabled():
|
|
if self.debug_app_active:
|
|
self.apps.append(self.debug_app)
|
|
else:
|
|
self.apps.remove(self.debug_app)
|
|
self.debug_app_active = self.config.debug_app_enabled()
|
|
else:
|
|
self.app_index += 1
|
|
print("Moving to the next app on the list. ")
|
|
self.swap_to_app(self.apps[self.app_index % len(self.apps)])
|
|
print("released encoder")
|
|
if self.encoder_state and self.click_time:
|
|
self.release_time = time.monotonic_ns()
|
|
if (time.monotonic_ns() - self.click_time) > self.options_time:
|
|
self.macropad.play_tone(1000, .1)
|
|
self.swap_to_app(self.options)
|
|
self.encoder_state = False
|
|
self.macropad.encoder_switch_debounced.update()
|