TaskManager: add stop and start functions

internal_filesystem/lib/mpos/main.py

@@ -106,14 +106,9 @@ if not started_launcher:
 else:
     mpos.TaskManager.create_task(ota_rollback_cancel()) # only gets started when mpos.TaskManager() is created 
 
-while True:
-    try:
-        mpos.TaskManager() # do this at the end because it doesn't return
-    except KeyboardInterrupt as k:
-        print(f"mpos.TaskManager() got KeyboardInterrupt, falling back to REPL shell...") # only works if no aiorepl is running
-        break
-    except Exception as e:
-        print(f"mpos.TaskManager() got exception: {e}")
-        print("Restarting mpos.TaskManager() after 10 seconds...")
-        import time
-        time.sleep(10)
+try:
+    mpos.TaskManager.start() # do this at the end because it doesn't return
+except KeyboardInterrupt as k:
+    print(f"mpos.TaskManager() got KeyboardInterrupt, falling back to REPL shell...") # only works if no aiorepl is running
+except Exception as e:
+    print(f"mpos.TaskManager() got exception: {e}")

internal_filesystem/lib/mpos/task_manager.py

@@ -5,21 +5,34 @@ import mpos.apps
 class TaskManager:
 
     task_list = [] # might be good to periodically remove tasks that are done, to prevent this list from growing huge
+    keep_running = True
 
-    def __init__(self):
-        print("TaskManager starting asyncio_thread")
-        # tiny stack size of 1024 is fine for tasks that do nothing
-        # but for real-world usage, it needs more:
-        #_thread.stack_size(mpos.apps.good_stack_size())
-        #_thread.start_new_thread(asyncio.run, (self._asyncio_thread(100), ))
-        asyncio.run(self._asyncio_thread(10)) # this actually works, but it blocks the real REPL (aiorepl works, but that's limited)
-
-    async def _asyncio_thread(self, ms_to_sleep):
+    @classmethod
+    async def _asyncio_thread(cls, ms_to_sleep):
         print("asyncio_thread started")
-        while True:
-            #print("asyncio_thread tick")
+        while TaskManager.should_keep_running() is True:
+        #while self.keep_running is True:
+            #print(f"asyncio_thread tick because {self.keep_running}")
+            print(f"asyncio_thread tick because {TaskManager.should_keep_running()}")
             await asyncio.sleep_ms(ms_to_sleep)  # This delay determines how quickly new tasks can be started, so keep it below human reaction speed
-        print("WARNING: asyncio_thread exited, this shouldn't happen because now asyncio.create_task() won't work anymore!")
+        print("WARNING: asyncio_thread exited, now asyncio.create_task() won't work anymore")
+
+    @classmethod
+    def start(cls):
+        #asyncio.run_until_complete(TaskManager._asyncio_thread(100)) # this actually works, but it blocks the real REPL (aiorepl works, but that's limited)
+        asyncio.run(TaskManager._asyncio_thread(1000)) # this actually works, but it blocks the real REPL (aiorepl works, but that's limited)
+
+    @classmethod
+    def stop(cls):
+        cls.keep_running = False
+
+    @classmethod
+    def should_keep_running(cls):
+        return cls.keep_running
+
+    @classmethod
+    def set_keep_running(cls, value):
+        cls.keep_running = value
 
     @classmethod
     def create_task(cls, coroutine):