Merge branch 'PokemonAutomation:main' into gba-rg35xxsp-test

Author: kichithewolf

Common/Cpp/Concurrency/ScheduledTaskRunner.cpp

@@ -20,33 +20,43 @@ ScheduledTaskRunner::~ScheduledTaskRunner(){
 //    ScheduledTaskRunner::cancel(nullptr);
     {
         std::lock_guard<std::mutex> lg(m_lock);
+//        cout << "ScheduledTaskRunner: (Destructor - start): " << this << endl;
         m_stopped = true;
         m_cv.notify_all();
     }
     m_runner.reset();
+//    cout << "ScheduledTaskRunner: (Destructor - end):   " << this << endl;
 }
 ScheduledTaskRunner::ScheduledTaskRunner(AsyncDispatcher& dispatcher)
     : m_stopped(false)
     , m_runner(dispatcher.dispatch([this]{ thread_loop(); }))
-{}
+{
+//    cout << "ScheduledTaskRunner: (Constructor): " << this << endl;
+}
 size_t ScheduledTaskRunner::size() const{
     std::lock_guard<std::mutex> lg(m_lock);
     return m_schedule.size();
 }
 WallClock ScheduledTaskRunner::next_event() const{
     std::lock_guard<std::mutex> lg(m_lock);
-    if (m_schedule.empty()){
+    if (m_stopped || m_schedule.empty()){
         return WallClock::max();
     }
     return m_schedule.begin()->first;
 }
 void ScheduledTaskRunner::add_event(WallClock time, std::function<void()> callback){
     std::lock_guard<std::mutex> lg(m_lock);
+    if (m_stopped){
+        return;
+    }
     m_schedule.emplace(time, std::move(callback));
     m_cv.notify_all();
 }
 void ScheduledTaskRunner::add_event(std::chrono::milliseconds time_from_now, std::function<void()> callback){
     std::lock_guard<std::mutex> lg(m_lock);
+    if (m_stopped){
+        return;
+    }
     m_schedule.emplace(current_time() + time_from_now, std::move(callback));
     m_cv.notify_all();
 }
@@ -62,6 +72,7 @@ bool ScheduledTaskRunner::cancel(std::exception_ptr exception) noexcept{
 #endif
 void ScheduledTaskRunner::thread_loop(){
     std::unique_lock<std::mutex> lg(m_lock);
+//    cout << "ScheduledTaskRunner: (Starting thread loop): " << this << endl;
 //    WallClock last_check_timestamp = current_time();
     while (!m_stopped){
 #if 0
@@ -71,7 +82,9 @@ void ScheduledTaskRunner::thread_loop(){
 #endif
 
         if (m_schedule.empty()){
+//            cout << "ScheduledTaskRunner: (Sleeping): " << this << endl;
             m_cv.wait(lg);
+//            cout << "ScheduledTaskRunner: (Waking): " << this << endl;
             continue;
         }
 
@@ -81,11 +94,15 @@ void ScheduledTaskRunner::thread_loop(){
             m_cv.wait_until(lg, item->first);
             continue;
         }
+//        cout << "ScheduledTaskRunner: (task - start): " << this << endl;
         lg.unlock();
         item->second();
         lg.lock();
+//        cout << "ScheduledTaskRunner: (task - end): " << this << endl;
         m_schedule.erase(item);
     }
+//    cout << "ScheduledTaskRunner: (Clearing schedule): " << this << endl;
+    m_schedule.clear();
 }
 
 

SerialPrograms/Source/CommonFramework/ErrorReports/ErrorReports.cpp

@@ -10,8 +10,10 @@
 #include "Common/Cpp/PrettyPrint.h"
 #include "Common/Cpp/Json/JsonArray.h"
 #include "Common/Cpp/Json/JsonObject.h"
+#include "Common/Cpp/Concurrency/AsyncDispatcher.h"
 #include "CommonFramework/Globals.h"
 #include "CommonFramework/GlobalSettingsPanel.h"
+#include "CommonFramework/GlobalServices.h"
 #include "CommonFramework/Logging/Logger.h"
 #include "CommonFramework/Notifications/ProgramNotifications.h"
 #include "CommonFramework/Environment/Environment.h"
@@ -165,56 +167,63 @@ SendableErrorReport::SendableErrorReport(std::string directory)
     JsonValue json = load_json_file(m_directory + "Report.json");
     const JsonObject& obj = json.to_object_throw();
     m_timestamp = obj.get_string_throw("Timestamp");
-    m_processor = obj.get_string_throw("Processor");
-    m_program = obj.get_string_throw("Program");
-    m_program_id = obj.get_string_throw("ProgramID");
-    m_program_runtime_millis = obj.get_integer_throw("ElapsedTimeMillis");
-    m_title = obj.get_string_throw("Title");
-    {
-        const JsonArray& messages = obj.get_array_throw("Messages");
-        for (const JsonValue& message : messages){
-            const JsonArray& item = message.to_array_throw();
-            if (item.size() != 2){
-                throw ParseException("Expected 2 values for message.");
+
+    //  If we error from this point on, we'll just move it to the sent folder.
+    try{
+        m_processor = obj.get_string_throw("Processor");
+        m_program = obj.get_string_throw("Program");
+        m_program_id = obj.get_string_throw("ProgramID");
+        m_program_runtime_millis = obj.get_integer_throw("ElapsedTimeMillis");
+        m_title = obj.get_string_throw("Title");
+        {
+            const JsonArray& messages = obj.get_array_throw("Messages");
+            for (const JsonValue& message : messages){
+                const JsonArray& item = message.to_array_throw();
+                if (item.size() != 2){
+                    throw ParseException("Expected 2 values for message.");
+                }
+                m_messages.emplace_back(
+                    item[0].to_string_throw(),
+                    item[1].to_string_throw()
+                );
             }
-            m_messages.emplace_back(
-                item[0].to_string_throw(),
-                item[1].to_string_throw()
-            );
         }
-    }
-    {
-        const std::string* image_name = obj.get_string("Screenshot");
-        if (image_name){
-            try{
-                m_image_owner = ImageRGB32(m_directory + *image_name);
-                m_image = m_image_owner;
-            }catch (FileException&){}
+        {
+            const std::string* image_name = obj.get_string("Screenshot");
+            if (image_name){
+                try{
+                    m_image_owner = ImageRGB32(m_directory + *image_name);
+                    m_image = m_image_owner;
+                }catch (FileException&){}
+            }
         }
-    }
-    {
-        const std::string* video_name = obj.get_string("Video");
-        if (video_name){
-            m_video_name = *video_name;
+        {
+            const std::string* video_name = obj.get_string("Video");
+            if (video_name){
+                m_video_name = *video_name;
+            }
         }
-    }
-    {
-        const std::string* dump_name = obj.get_string("Dump");
-        if (dump_name){
-            m_dump_name = *dump_name;
+        {
+            const std::string* dump_name = obj.get_string("Dump");
+            if (dump_name){
+                m_dump_name = *dump_name;
+            }
         }
-    }
-    {
-        const std::string* logs_name = obj.get_string("Logs");
-        if (logs_name){
-            m_logs_name = *logs_name;
+        {
+            const std::string* logs_name = obj.get_string("Logs");
+            if (logs_name){
+                m_logs_name = *logs_name;
+            }
         }
-    }
-    {
-        const JsonArray& files = obj.get_array_throw("Files");
-        for (const JsonValue& file : files){
-            m_files.emplace_back(file.to_string_throw());
+        {
+            const JsonArray& files = obj.get_array_throw("Files");
+            for (const JsonValue& file : files){
+                m_files.emplace_back(file.to_string_throw());
+            }
         }
+    }catch (...){
+        move_to_sent();
+        throw;
     }
 }
 void SendableErrorReport::add_file(std::string filename){
@@ -270,23 +279,22 @@ void SendableErrorReport::save(Logger* logger) const{
     report.dump(m_directory + "Report.json");
 }
 
-#ifndef PA_OFFICIAL
-bool SendableErrorReport::send(Logger& logger){
-    return false;
-}
-#endif
-
 void SendableErrorReport::move_to_sent(){
 //    cout << "move_to_sent()" << endl;
     QDir().mkdir(QString::fromStdString(ERROR_PATH_SENT));
 
     std::string new_directory = ERROR_PATH_SENT + "/" + m_timestamp + "/";
 //    cout << "old: " << m_directory << endl;
 //    cout << "new: " << new_directory << endl;
-    QDir().rename(
+    bool success = QDir().rename(
         QString::fromStdString(m_directory),
         QString::fromStdString(new_directory)
     );
+    if (success){
+        global_logger_tagged().log("Moved error report " + m_timestamp + ".");
+    }else{
+        global_logger_tagged().log("Unable to move error report " + m_timestamp + ".", COLOR_RED);
+    }
     m_directory = std::move(new_directory);
 }
 
@@ -306,37 +314,46 @@ std::vector<std::string> SendableErrorReport::get_pending_reports(){
     return ret;
 }
 
+#ifndef PA_OFFICIAL
+void SendableErrorReport::send(Logger& logger, std::shared_ptr<SendableErrorReport> report){}
+#endif
+
 
 
+//  Send all the reports. This function will return early and all the reports
+//  will be sent asynchronously in the background.
 void send_reports(Logger& logger, const std::vector<std::string>& reports){
     for (const std::string& path : reports){
         try{
-            SendableErrorReport report(path);
-            report.send(logger);
+//            static int c = 0;
+//            cout << "Sending... " << c++ << endl;
+            //  std:::shared_ptr because it needs to take ownership for
+            //  destruction at a later time.
+            SendableErrorReport::send(logger, std::make_shared<SendableErrorReport>(path));
         }catch (Exception& e){
             logger.log("Unable to send report: " + path + ", Message: " + e.to_str(), COLOR_RED);
         }catch (...){
             logger.log("Unable to send report: " + path, COLOR_RED);
         }
     }
 }
-void send_all_unsent_reports(Logger& logger, bool allow_prompt){
+std::unique_ptr<AsyncTask> send_all_unsent_reports(Logger& logger, bool allow_prompt){
 #ifdef PA_OFFICIAL
     ErrorReportSendMode mode = GlobalSettings::instance().ERROR_REPORTS->SEND_MODE;
     if (mode == ErrorReportSendMode::NEVER_SEND_ANYTHING){
-        return;
+        return nullptr;
     }
 
     std::vector<std::string> reports = SendableErrorReport::get_pending_reports();
     global_logger_tagged().log("Found " + std::to_string(reports.size()) + " unsent error reports.", COLOR_PURPLE);
 
     if (reports.empty()){
-        return;
+        return nullptr;
     }
 
     if (mode == ErrorReportSendMode::PROMPT_WHEN_CONVENIENT){
         if (!allow_prompt){
-            return;
+            return nullptr;
         }
         QMessageBox box;
         QMessageBox::StandardButton button = box.information(
@@ -356,13 +373,17 @@ void send_all_unsent_reports(Logger& logger, bool allow_prompt){
             QMessageBox::StandardButton::Yes
         );
         if (button != QMessageBox::StandardButton::Yes){
-            return;
+            return nullptr;
         }
     }
 
     global_logger_tagged().log("Attempting to send " + std::to_string(reports.size()) + " error reports.", COLOR_PURPLE);
-    send_reports(global_logger_tagged(), reports);
 
+    return global_async_dispatcher().dispatch([reports = std::move(reports)]{
+        send_reports(global_logger_tagged(), reports);
+    });
+#else
+    return nullptr;
 #endif
 }
 

SerialPrograms/Source/CommonFramework/ErrorReports/ErrorReports.h

@@ -7,6 +7,7 @@
 #ifndef PokemonAutomation_ErrorReports_H
 #define PokemonAutomation_ErrorReports_H
 
+#include <memory>
 #include "Common/Cpp/AbstractLogger.h"
 #include "Common/Cpp/Options/GroupOption.h"
 #include "Common/Cpp/Options/StaticTextOption.h"
@@ -19,6 +20,7 @@
 namespace PokemonAutomation{
 
 
+class AsyncTask;
 class ConsoleHandle;
 
 
@@ -76,10 +78,10 @@ class SendableErrorReport{
     void add_file(std::string filename);
 
     void save(Logger* logger) const;
-    bool send(Logger& logger);
     void move_to_sent();
 
     static std::vector<std::string> get_pending_reports();
+    static void send(Logger& logger, std::shared_ptr<SendableErrorReport> report);
 
 private:
     std::string m_timestamp;
@@ -100,7 +102,7 @@ class SendableErrorReport{
 
 
 void send_reports(Logger& logger, const std::vector<std::string>& reports);
-void send_all_unsent_reports(Logger& logger, bool allow_prompt);
+std::unique_ptr<AsyncTask> send_all_unsent_reports(Logger& logger, bool allow_prompt);
 
 
 void report_error(

SerialPrograms/Source/CommonFramework/GlobalServices.cpp

@@ -4,18 +4,18 @@
  *
  */
 
-//#include "Common/Cpp/Concurrency/ScheduledTaskRunner.h"
+#include "Common/Cpp/Concurrency/ScheduledTaskRunner.h"
 #include "Common/Cpp/Concurrency/Watchdog.h"
 #include "GlobalServices.h"
 
 namespace PokemonAutomation{
 
 
-#if 0
 AsyncDispatcher& global_async_dispatcher(){
     static AsyncDispatcher dispatcher(nullptr, 1);
     return dispatcher;
 }
+#if 0
 ScheduledTaskRunner& global_scheduled_task_runner(){
     static ScheduledTaskRunner runner(global_async_dispatcher());
     return runner;

SerialPrograms/Source/CommonFramework/GlobalServices.h

@@ -14,7 +14,7 @@ class ScheduledTaskRunner;
 class Watchdog;
 
 
-//AsyncDispatcher& global_async_dispatcher();
+AsyncDispatcher& global_async_dispatcher();
 //ScheduledTaskRunner& global_scheduled_task_runner();
 Watchdog& global_watchdog();
 

SerialPrograms/Source/CommonFramework/Inference/BlackScreenDetector.h

@@ -66,7 +66,7 @@ class BlackScreenWatcher : public DetectorToFinder<BlackScreenDetector>{
         double max_rgb_sum = 100,
         double max_stddev_sum = 10,
         FinderType finder_type = FinderType::PRESENT,
-        std::chrono::milliseconds duration = std::chrono::milliseconds(250)
+        std::chrono::milliseconds duration = std::chrono::milliseconds(100)
     )
         : DetectorToFinder("BlackScreenWatcher", finder_type, duration, color, box, max_rgb_sum, max_stddev_sum)
     {}
@@ -80,8 +80,8 @@ class BlackScreenOverWatcher : public VisualInferenceCallback{
         const ImageFloatBox& box = {0.1, 0.1, 0.8, 0.8},
         double max_rgb_sum = 100,
         double max_stddev_sum = 10,
-        std::chrono::milliseconds hold_duration = std::chrono::milliseconds(250),
-        std::chrono::milliseconds release_duration = std::chrono::milliseconds(250)
+        std::chrono::milliseconds hold_duration = std::chrono::milliseconds(100),
+        std::chrono::milliseconds release_duration = std::chrono::milliseconds(100)
     );
 
     bool black_is_over(const ImageViewRGB32& frame);