Fix task manager

Author: Tawank

src/modules/bjs_interpreter/functions_js.cpp

@@ -9,6 +9,7 @@
 #include "display_js.h"
 #include "gui_js.h"
 #include "helpers_js.h"
+#include "interpreter.h"
 #include "wifi_js.h"
 
 duk_ret_t native_noop(duk_context *ctx) { return 0; }
@@ -33,10 +34,42 @@ duk_ret_t native_now(duk_context *ctx) {
 }
 
 duk_ret_t native_delay(duk_context *ctx) {
+    duk_push_global_object(ctx);
+    duk_push_string(ctx, DUK_HIDDEN_SYMBOL("INTERPRETER_POINTER"));
+    duk_get_prop(ctx, -2);
+    InterpreterJS *interpreterJS = (InterpreterJS *)duk_get_pointer(ctx, -1);
+    interpreterJS->_isExecuting = false;
+
+    if (interpreterJS->shouldTerminate == false) {
+        interpreterJS->terminate(true);
+        return 0;
+    }
+
     delay(duk_to_int(ctx, 0));
     return 0;
 }
 
+duk_ret_t native_sleep(duk_context *ctx) {
+    duk_push_global_object(ctx);
+    duk_push_string(ctx, DUK_HIDDEN_SYMBOL("INTERPRETER_POINTER"));
+    duk_get_prop(ctx, -2);
+    InterpreterJS *interpreterJS = (InterpreterJS *)duk_get_pointer(ctx, -1);
+    interpreterJS->_isExecuting = false;
+
+    if (interpreterJS->shouldTerminate == false) {
+        interpreterJS->terminate(true);
+        return 0;
+    }
+
+    duk_int_t delayMs = duk_to_int(ctx, 0);
+
+    for (int i = 0; i < delayMs; i += 10) {
+        delay(10);
+        if (interpreterJS->isForeground) break;
+    }
+    return 0;
+}
+
 duk_ret_t native_assert(duk_context *ctx) {
     if (duk_get_boolean_default(ctx, 0, false)) {
         duk_push_boolean(ctx, true);

src/modules/bjs_interpreter/functions_js.h

@@ -11,6 +11,7 @@ duk_ret_t native_serialPrintln(duk_context *ctx);
 
 duk_ret_t native_now(duk_context *ctx);
 duk_ret_t native_delay(duk_context *ctx);
+duk_ret_t native_sleep(duk_context *ctx);
 duk_ret_t native_assert(duk_context *ctx);
 duk_ret_t native_random(duk_context *ctx);
 

src/modules/bjs_interpreter/interpreter.cpp

@@ -108,9 +108,13 @@ void interpreterHandler(void *pvParameters) {
     duk_context *ctx =
         duk_create_heap(alloc_function, realloc_function, free_function, NULL, js_fatal_error_handler);
 
+    duk_push_pointer(ctx, interpreterJS);
+    duk_put_global_string(ctx, DUK_HIDDEN_SYMBOL("INTERPRETER_POINTER"));
+
     // Add native functions to context.
     bduk_register_c_lightfunc(ctx, "now", native_now, 0);
     bduk_register_c_lightfunc(ctx, "delay", native_delay, 1);
+    bduk_register_c_lightfunc(ctx, "sleep", native_sleep, 1);
     bduk_register_c_lightfunc(ctx, "parse_int", native_parse_int, 1);
     bduk_register_c_lightfunc(ctx, "to_string", native_to_string, 1);
     bduk_register_c_lightfunc(ctx, "to_hex_string", native_to_hex_string, 1);
@@ -359,26 +363,32 @@ InterpreterJS::InterpreterJS(char *script, const char *scriptName, const char *s
 
 InterpreterJS::~InterpreterJS() { terminate(); }
 
-void InterpreterJS::terminate() {
+void InterpreterJS::toForeground() {}
+
+void InterpreterJS::toBackground() {}
 
-    if (isRunning == false) {
+void InterpreterJS::terminate(bool waitForTermination) {
+    if (_isExecuting && waitForTermination) {
+        while (_isExecuting == true) { delay(100); }
+    }
+
+    if (_isExecuting == false) {
         vTaskDelete(taskHandle);
         taskHandle = nullptr;
-        isRunning = false;
 
         taskManager.unregisterTask(taskId);
-        free((char *)script);
+        free(script);
         script = NULL;
 
         if (ctx) {
             duk_destroy_heap(ctx);
             ctx = nullptr;
         }
+    } else {
+        shouldTerminate = true;
     }
 }
 
-uint8_t InterpreterJS::getState() { return 1; }
-
 // function to start the JS Interpreterm choosinng the file, processing and
 // start
 void run_bjs_script() {
@@ -397,13 +407,14 @@ void run_bjs_script() {
     if (script == NULL) { return; }
 
     new InterpreterJS(script, filename.c_str());
-
-    returnToMenu = true;
 }
 
 bool run_bjs_script_headless(char *code) {
+    Task *task = taskManager.getTaskByName("eval");
+    if (task != nullptr) { task->terminate(true); }
+
     new InterpreterJS(code, "eval");
-    returnToMenu = true;
+
     return true;
 }
 

src/modules/bjs_interpreter/interpreter.h

@@ -17,18 +17,22 @@ class InterpreterJS : Task {
     const char *getName() { return scriptName.c_str(); };
     const char *getScriptDirpath() { return scriptDirpath.c_str(); };
     const char *getScript() { return script; };
-    // void start();
-    void terminate();
-    uint8_t getState();
-    // duk_context *getContext();
+
+    void toForeground();
+    void toBackground();
+
+    void terminate(bool waitForTermination = false);
+
+    bool _isExecuting = false;
+    bool shouldTerminate = false;
+    bool isForeground = true;
 
 private:
     int taskId;
     char *script;
-    String scriptDirpath;
     String scriptName;
-    bool isRunning;
-    bool shouldTerminate;
+    String scriptDirpath;
+
     TaskHandle_t taskHandle = nullptr;
     duk_context *ctx = nullptr;
 };
@@ -38,6 +42,6 @@ void run_bjs_script();
 void interpreterHandler(void *pvParameters);
 
 bool run_bjs_script_headless(char *code);
-bool run_bjs_script_headless(FS fs, String filename);
+bool run_bjs_script_headless(FS &fs, String filename);
 
 #endif

src/modules/bjs_interpreter/task_manager.cpp

@@ -13,7 +13,7 @@ TaskManager::~TaskManager() {
     tasks.clear();
 }
 
-Task *TaskManager::getTaskById(uint8_t id) {
+Task *TaskManager::getTaskById(int8_t id) {
     if (id < tasks.size()) { return tasks[id]; }
     return nullptr;
 }
@@ -25,14 +25,14 @@ Task *TaskManager::getTaskByName(const char *name) {
     return nullptr;
 }
 
-uint8_t TaskManager::registerTask(Task *task) {
+int8_t TaskManager::registerTask(Task *task) {
     if (!task) return -1;
 
     tasks.push_back(task);
     return tasks.size() - 1;
 }
 
-bool TaskManager::unregisterTask(uint8_t taskId) {
+bool TaskManager::unregisterTask(int8_t taskId) {
     if (taskId == -1) return false;
     auto task = tasks[taskId];
     task->terminate();

src/modules/bjs_interpreter/task_manager.h

@@ -6,21 +6,25 @@
 
 class Task {
 public:
+    virtual ~Task() {};
     virtual const char *getName() = 0;
-    virtual void terminate() = 0;
-    virtual uint8_t getState() = 0;
+
+    virtual void toForeground() = 0;
+    virtual void toBackground() = 0;
+
+    virtual void terminate(bool waitForTermination = false) = 0;
 };
 
 class TaskManager {
 public:
     TaskManager();
     ~TaskManager();
 
-    Task *getTaskById(uint8_t id);
+    Task *getTaskById(int8_t id);
     Task *getTaskByName(const char *name);
 
-    uint8_t registerTask(Task *task);
-    bool unregisterTask(uint8_t taskId);
+    int8_t registerTask(Task *task);
+    bool unregisterTask(int8_t taskId);
 
 private:
     std::vector<Task *> tasks;