Improve Gradle Task Runner (#819)

* Add streaming to gradle output
* Add multiple gradle tasks

Author: CedNaru

src/editor/build/build_manager.cpp

@@ -0,0 +1,119 @@
+
+#ifdef TOOLS_ENABLED
+
+#include "../godot_kotlin_jvm_editor.h"
+#include "editor/strings.h"
+#include "gradle_task_runner.h"
+#include "logging.h"
+
+#include <core/config/project_settings.h>
+
+Mutex build_mutex {};
+
+String get_build_gradle_path() {
+    String gradle_wrapper_path {ProjectSettings::get_singleton()->globalize_path(GLOBAL_GET(gradle_dir))};
+    return gradle_wrapper_path.path_join("build.gradle.kts");
+}
+
+String get_gradlew_path() {
+#if defined _WIN32 || defined _WIN64
+    String gradle_wrapper {"gradlew.bat"};
+#else
+    String gradle_wrapper {"gradlew"};
+#endif
+
+    String gradle_wrapper_path {ProjectSettings::get_singleton()->globalize_path(GLOBAL_GET(gradle_dir))};
+    return gradle_wrapper_path.path_join(gradle_wrapper);
+}
+
+Error GradleTaskRunner::run_task(int task_id, String& log, bool blocking) {
+    JVM_ERR_FAIL_COND_V_MSG(
+      !FileAccess::create(FileAccess::AccessType::ACCESS_RESOURCES)->file_exists(get_build_gradle_path()),
+      Error::ERR_FILE_NOT_FOUND,
+      missing_gradle_project
+    );
+
+    List<String> args {};
+    switch (task_id) {
+        case Task::BUILD_DEBUG:
+            args.push_back("build");
+            break;
+        case Task::BUILD_RELEASE:
+            args.push_back("build");
+            args.push_back("-Prelease=true");
+            break;
+        case Task::GENERATE_EMBEDDED_JVM:
+            args.push_back("generateEmbeddedJre");
+            break;
+        default:
+            return Error::ERR_INVALID_PARAMETER;
+    }
+
+    String gradlew_path = get_gradlew_path();
+
+    if (blocking) {
+        int exit_code;
+        Error result = OS::get_singleton()->execute(gradlew_path, args, &log, &exit_code, true, &build_mutex, false);
+        return result;
+    } else {
+        Dictionary info = OS::get_singleton()->execute_with_pipe(gradlew_path, args, /*blocking=*/false);
+
+        if (info.is_empty()) { JVM_ERR_FAIL_V_MSG(Error::ERR_CANT_CREATE, "Failed to start process"); }
+
+        log = vformat("Running gradle task: %s", args.get(0));
+        stdio = info["stdio"];
+        stderr_io = info["stderr"];
+        pid = info["pid"];
+    }
+
+    return Error::OK;
+}
+
+GradleTaskRunner& GradleTaskRunner::get_instance() {
+    static GradleTaskRunner instance;
+    return instance;
+}
+
+bool GradleTaskRunner::is_task_started() {
+    return pid > -1;
+}
+
+bool GradleTaskRunner::is_task_terminated() {
+    bool ret = !OS::get_singleton()->is_process_running(pid);
+    if (ret) { reset(); }
+    return ret;
+}
+
+void GradleTaskRunner::get_task_output(String& log, String& error) {
+    if (stdio.is_valid()) {
+        // keep reading until no full line is available
+        Error err;
+        do {
+            String line = stdio->get_line();
+            err = stdio->get_error();
+            if (!line.is_empty()) { log += line + "\n"; }
+        } while (err == OK);
+    }
+
+    if (stderr_io.is_valid()) {
+        // keep reading until no full line is available
+        Error err;
+        do {
+            String line = stderr_io->get_line();
+            err = stderr_io->get_error();
+            if (!line.is_empty()) { error += line + "\n"; }
+        } while (err == OK);
+    }
+}
+
+void GradleTaskRunner::reset() {
+    stdio = {};
+    stderr_io = {};
+    pid = -1;
+}
+
+void GradleTaskRunner::cleanup() {
+    reset();
+}
+
+#endif // TOOLS_ENABLED

src/editor/build/build_manager.h

@@ -0,0 +1,43 @@
+
+#ifdef TOOLS_ENABLED
+
+#ifndef GODOT_JVM_BUILD_MANAGER_H
+#define GODOT_JVM_BUILD_MANAGER_H
+
+#include <core/object/worker_thread_pool.h>
+#include <core/os/os.h>
+#include <core/os/thread.h>
+
+class GradleTaskRunner {
+public:
+    enum Task {
+        BUILD_DEBUG,
+        BUILD_RELEASE,
+        GENERATE_EMBEDDED_JVM
+    };
+
+private:
+    Ref<FileAccess> stdio;
+    Ref<FileAccess> stderr_io;
+    int pid = -1;
+
+    GradleTaskRunner() = default;
+
+    void reset();
+
+public:
+    static GradleTaskRunner& get_instance();
+    void cleanup();
+
+    GradleTaskRunner(const GradleTaskRunner&) = delete;
+    GradleTaskRunner& operator=(const GradleTaskRunner&) = delete;
+
+    Error run_task(int task_id, String& log, bool blocking);
+    bool is_task_started();
+    bool is_task_terminated();
+    void get_task_output(String& log, String& error);
+};
+
+#endif // GODOT_JVM_BUILD_MANAGER_H
+
+#endif // TOOLS_ENABLED

src/editor/build/gradle_task_runner.cpp

@@ -3,40 +3,61 @@
 
 #include "build_dialog.h"
 
-#include "editor/build/build_manager.h"
+#include "editor/build/gradle_task_runner.h"
 #include "logging.h"
 
 #include <editor/themes/editor_scale.h>
 
-BuildDialog::BuildDialog() : scroll_container(memnew(ScrollContainer)), log_label(memnew(Label)) {
-    set_title("Godot Kotlin/JVM Gradle build");
+TaskDialog::TaskDialog() :
+  scroll_container(memnew(ScrollContainer)),
+  log_label(memnew(Label)),
+  progress_bar(memnew(ProgressBar)),
+  vertical_container(memnew(VBoxContainer)) {
+    set_title("Gradle Task Runner");
 }
 
-void BuildDialog::set_scrollbar_at_bottom() {
+void TaskDialog::set_scrollbar_at_bottom() {
     scroll_container->set_v_scroll(static_cast<int>(scroll_container->get_v_scroll_bar()->get_max()));
 }
 
-void BuildDialog::update_state(String log) {
-    log_label->set_text(log);
-    JVM_LOG_INFO(log);
-
+void TaskDialog::make_appear() {
+    log_label->set_text("");
+    set_transient(true);
+    set_exclusive(true);
+    progress_bar->show();
     popup_centered();
+}
+
+void TaskDialog::update_state(String log) {
+    if (log.is_empty()) { return; }
+    log_label->set_text(log_label->get_text() + log);
 
     StringName signal = SNAME("draw");
-    Callable callback = callable_mp(this, &BuildDialog::set_scrollbar_at_bottom);
+    Callable callback = callable_mp(this, &TaskDialog::set_scrollbar_at_bottom);
 
     if (!scroll_container->is_connected(signal, callback)) {
         scroll_container->connect(signal, callback, CONNECT_ONE_SHOT);
     }
 }
 
-void BuildDialog::_notification(int notification) {
+void TaskDialog::stop() {
+    progress_bar->hide();
+    set_exclusive(false);
+}
+
+void TaskDialog::_notification(int notification) {
     if (notification != NOTIFICATION_ENTER_TREE) { return; }
     scroll_container->set_custom_minimum_size(Size2 {600, 400} * EDSCALE);
-    add_child(scroll_container);
+    vertical_container->add_child(scroll_container);
 
     log_label->set_h_size_flags(Control::SizeFlags::SIZE_EXPAND_FILL);
     scroll_container->add_child(log_label);
+
+    progress_bar->set_editor_preview_indeterminate(true);
+    progress_bar->set_indeterminate(true);
+    vertical_container->add_child(progress_bar);
+
+    add_child(vertical_container);
 }
 
-#endif// TOOLS_ENABLED
+#endif // TOOLS_ENABLED

src/editor/build/gradle_task_runner.h

@@ -5,22 +5,27 @@
 #define GODOT_JVM_BUILD_DIALOG_H
 
 #include <scene/gui/dialogs.h>
+#include <scene/gui/progress_bar.h>
 #include <scene/gui/scroll_container.h>
 
-class BuildDialog : public AcceptDialog {
-    GDCLASS(BuildDialog, AcceptDialog)
+class TaskDialog : public AcceptDialog {
+    GDCLASS(TaskDialog, AcceptDialog)
 
     ScrollContainer* scroll_container;
     Label* log_label;
+    ProgressBar* progress_bar;
+    VBoxContainer* vertical_container;
 
 public:
-    BuildDialog();
+    TaskDialog();
 
     void set_scrollbar_at_bottom();
+    void make_appear();
     void update_state(String log);
+    void stop();
     void _notification(int notification);
 };
 
-#endif// GODOT_JVM_BUILD_DIALOG_H
+#endif // GODOT_JVM_BUILD_DIALOG_H
 
-#endif// TOOLS_ENABLED
+#endif // TOOLS_ENABLED