feat: Adding support for json apps. Updated Macropad_os.py to automatically load in the python and json apps at launch.

macropad_os/abstract_app.py

@@ -143,12 +143,13 @@ class App(object):
 
     def _stop_tone_for_key(self, key_number):
         self.macropad.stop_tone()
-        self._pressed_keys.remove(key_number)
-        if self._pressed_keys and self.config.key_tone_enabled():
-            if key_number in self._key_tones:
-                self.macropad.start_tone(self._key_tones[self._pressed_keys[0]])
-            else:
-                self.macropad.start_tone(self.config.key_tone_hz())
+        if key_number in self._pressed_keys:
+            self._pressed_keys.remove(key_number)
+            if self._pressed_keys and self.config.key_tone_enabled():
+                if key_number in self._key_tones:
+                    self.macropad.start_tone(self._key_tones[self._pressed_keys[0]])
+                else:
+                    self.macropad.start_tone(self.config.key_tone_hz())
 
     def _process_wheel_changes(self) -> None:
         encoder = self.macropad.encoder

macropad_os/macropad_os.py

@@ -1,23 +1,29 @@
-import time
+import time, os
+
+from . import App
 from .app_state import AppState
 
-from macropad_os.system_apps import OptionsApp, DebugApp
+from macropad_os.system_apps import OptionsApp, DebugApp, JsonApp
 
 
 class MacropadOS(object):
-    def __init__(self, macropad, config, apps):
+    def __init__(self, macropad, config, python_apps: str, json_apps: str):
         print("app router")
         self.macropad = macropad
         self.app_index = 0
-        self.apps = [a(macropad, config) for a in apps]
         self.options = OptionsApp(macropad, config)
-        self.current_app = self.apps[self.app_index]
         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)
 
@@ -38,6 +44,39 @@ class MacropadOS(object):
             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()

macropad_os/system_apps/__init__.py

@@ -1,2 +1,3 @@
 from .debug_app import DebugApp
-from .options_app import OptionsApp
+from .options_app import OptionsApp
+from .json_app import JsonApp

macropad_os/system_apps/json_app.py

@@ -0,0 +1,134 @@
+import terminalio
+import json
+
+from time import monotonic_ns
+
+from adafruit_display_text.bitmap_label import Label
+from adafruit_displayio_layout.layouts.grid_layout import GridLayout
+from adafruit_hid.keycode import Keycode
+from macropad_os import App
+from macropad_os.app_utils import rgb_from_int, Macro, MacroSet
+from rainbowio import colorwheel
+
+COLOR_UPDATE_RATE = 33000000  # .033 seconds
+
+JSON_FILE_LOCATION = "./macropad_apps/json/"
+
+PROFILE_NAME = "profileName"
+SORT_ORDER = "sortOrder"
+KEY_KEYS = ["key1", "key2", "key3", "key4", "key5", "key6", "key7", "key8", "key9", "key10", "key11", "key12"]
+REQUIRED_KEYS = KEY_KEYS.copy()
+REQUIRED_KEYS.extend(x for x in [PROFILE_NAME, SORT_ORDER])
+
+
+class JsonApp(App):
+    def __init__(self, macropad, config, json_file):
+        super().__init__(macropad, config)
+        self.json_file = json_file
+        self.wheel_offset = 0
+        self.labels = []
+        self.title = ""
+        self.last_color_update = 0
+        self.active_macro = 0
+        self.name = "JSON_APP"
+        self.json_dict = JsonApp.read_json_file(self.json_file)
+        self.macros = JsonApp.get_macroset_from_dict(self.json_dict)
+        self.title = self.json_dict[PROFILE_NAME]
+        self.sort_order = self.json_dict[SORT_ORDER]
+
+    @staticmethod
+    def create_macro_from_dict(key_dict) -> Macro:
+        print(f"Creating macro for {key_dict}")
+        name = key_dict["text"]
+        values = key_dict["values"]
+        codes = []
+        for value in values:
+            if isinstance(value, str):
+                value_mod = 1
+                if value[0] is '-':
+                    value_mod = -1
+                    value = value[1:]
+                if hasattr(Keycode, value):
+                    keycode = getattr(Keycode, value)
+                    codes.append(keycode * value_mod)
+                else:
+                    codes.append(value)
+            if isinstance(value, int) or isinstance(value, float) or isinstance(value, dict) or isinstance(value, list):
+                # TODO: Add validation for lists and dictionaries
+                codes.append(value)
+        print(name, codes)
+        return Macro(name, *codes)
+
+    @staticmethod
+    def get_macroset_from_dict(json_dict: {}) -> MacroSet:
+        key_macros = []
+        for key in KEY_KEYS:
+            key_macros.append(JsonApp.create_macro_from_dict(json_dict[key]))
+        return MacroSet(key_macros=key_macros, encoder_up=Macro("Test"), encoder_down=Macro("Test"))
+
+    @staticmethod
+    def read_json_file(json_file) -> {}:
+        try:
+            f = open(json_file, "r")
+            json_dict = json.load(f)
+            print(json_dict)
+            for key in REQUIRED_KEYS:
+                if key not in json_dict:
+                    raise ValueError(f"JSON FOR FILE - {json_file} IS INVALID - KEY MISSING {key}")
+            return json_dict
+        except Exception as e:
+            print(e)
+
+    def on_start(self):
+        print("on start from the app!")
+        self.set_layout(GridLayout(x=0, y=9, width=128, height=54, grid_size=(3, 4), cell_padding=1))
+        self.set_title(self.title)
+        for i in range(12):
+            self.labels.append(
+                Label(terminalio.FONT, text=self.macros.get_macro_from_key(i).name))
+        for index in range(12):
+            x = index % 3
+            y = index // 3
+            self._layout.add_content(self.labels[index], grid_position=(x, y), cell_size=(1, 1))
+        self.register_on_key_pressed(self.process_keys_pressed_callback)
+        self.register_on_key_released(self.process_keys_released_callback)
+        self.register_on_encoder_changed(self.process_enbcoder_changed)
+
+    def on_resume(self):
+        print("resume from the debug app!")
+
+    def on_pause(self):
+        print("Pausing")
+
+    def on_stop(self):
+        print("Stopping")
+
+    def on_loop(self):
+        self.update_key_colors()
+
+    def update_key_colors(self):
+        self.wheel_offset += 1
+        colors = []
+        last_update_ago = monotonic_ns() - self.last_color_update
+        if last_update_ago > COLOR_UPDATE_RATE:
+            self.last_color_update = monotonic_ns()
+        for pixel in range(12):
+            (r, g, b) = rgb_from_int(colorwheel((pixel / 12 * 256) + self.wheel_offset))
+            colors.append((r, g, b))
+        self.set_colors(colors)
+
+    def process_keys_pressed_callback(self, key_event):
+        print(f"KEY PRESSED - {key_event}")
+        print(self.macros)
+        macro = self.macros.get_macro_from_key(key_event)
+        print(macro)
+        print(macro.name)
+        print(macro.codes)
+
+        self.press_macro(self.macros.get_macro_from_key(key_event))
+
+    def process_keys_released_callback(self, key_event):
+        self.release_macro(self.macros.get_macro_from_key(key_event))
+
+    def process_enbcoder_changed(self, key_event):
+        print(key_event)