More refactor to prepare for new input types.

Author: Mysticial

SerialPrograms/Source/CommonFramework/Main.cpp

@@ -28,7 +28,7 @@
 #include "Startup/NewVersionCheck.h"
 #include "CommonFramework/VideoPipeline/Backends/CameraImplementations.h"
 #include "CommonTools/OCR/OCR_RawOCR.h"
-#include "ControllerInput/Keyboard/GlobalKeyboardHidTracker.h"
+#include "ControllerInput/ControllerInput.h"
 #include "Windows/MainWindow.h"
 
 #include <iostream>
@@ -178,7 +178,7 @@ int main(int argc, char *argv[]){
 #endif
 
     //  Stop the controllers.
-    global_keyboard_tracker().stop();
+    global_input_stop();
 
     //  Force stop the thread pool
     PokemonAutomation::GlobalThreadPools::realtime_inference().stop();

SerialPrograms/Source/ControllerInput/ControllerInput.cpp

@@ -4,12 +4,78 @@
  *
  */
 
+#include <vector>
 #include "ControllerInput.h"
 
+#include "Keyboard/GlobalKeyboardHidTracker.h"
+
 namespace PokemonAutomation{
 
 
 
+class GlobalInputSources{
+public:
+    GlobalInputSources(){
+        //
+        //  When we add more input types, add them here.
+        //
+
+        m_input_sources.emplace_back(&global_keyboard_tracker());
+
+    }
+
+    void stop(){
+        for (ControllerInputSource* source : m_input_sources){
+            source->stop();
+        }
+    }
+    void clear_state(){
+        for (ControllerInputSource* source : m_input_sources){
+            source->clear_state();
+        }
+    }
+    void add_listener(ControllerInputListener& listener){
+        for (ControllerInputSource* source : m_input_sources){
+            source->add_listener(listener);
+        }
+    }
+    void remove_listener(ControllerInputListener& listener){
+        for (ControllerInputSource* source : m_input_sources){
+            source->remove_listener(listener);
+        }
+    }
+
+
+private:
+    std::vector<ControllerInputSource*> m_input_sources;
+};
+
+
+
+
+
+
+GlobalInputSources& global_input_sources(){
+    static GlobalInputSources sources;
+    return sources;
+}
+
+
+
+
+void global_input_stop(){
+    global_input_sources().stop();
+}
+void global_input_clear_state(){
+    global_input_sources().clear_state();
+}
+void global_input_add_listener(ControllerInputListener& listener){
+    global_input_sources().add_listener(listener);
+}
+void global_input_remove_listener(ControllerInputListener& listener){
+    global_input_sources().remove_listener(listener);
+}
+
 
 
 

SerialPrograms/Source/ControllerInput/ControllerInput.h

@@ -8,6 +8,7 @@
 #define PokemonAutomation_ControllerInput_ControllerInput_H
 
 #include "Common/Compiler.h"
+#include "Common/Cpp/ListenerSet.h"
 
 namespace PokemonAutomation{
 
@@ -42,13 +43,69 @@ class ControllerInputState{
 
 
 
-
 struct ControllerInputListener{
     virtual void run_controller_input(ControllerInputState& state){}
 };
 
 
 
 
+
+class ControllerInputSource{
+public:
+    //  This called before program shutdown. Child classes should shutdown any
+    //  threads they own to avoid static-deinit shenanigans.
+    virtual void stop() = 0;
+
+    //  User has switched away from the current console.
+    //  Release all buttons and reset back to neutral state.
+    virtual void clear_state() = 0;
+
+    //  These are called when controller inputs are enabled/disabled.
+    void add_listener(ControllerInputListener& listener){
+        m_listeners.add(listener);
+    }
+    void remove_listener(ControllerInputListener& listener){
+        m_listeners.remove(listener);
+    }
+
+protected:
+    ListenerSet<ControllerInputListener> m_listeners;
+};
+
+
+
+//  This is called at the end of main() before program shutdown. This allows all
+//  inputs to end their threads to avoid static-deinit shenanigans.
+void global_input_stop();
+
+//  This is called whenever the user switches away from the current console.
+//  Release all buttons and reset back to neutral state.
+void global_input_clear_state();
+
+//  These are called when controller inputs are enabled/disabled as a result
+//  of switching to/from a console or starting/stopping a program.
+void global_input_add_listener(ControllerInputListener& listener);
+void global_input_remove_listener(ControllerInputListener& listener);
+
+
+
+
+
+
+
+
+
+
+
 }
 #endif
+
+
+
+
+
+
+
+
+

SerialPrograms/Source/ControllerInput/Keyboard/GlobalKeyboardHidTracker.h

@@ -9,7 +9,6 @@
 
 #include <set>
 #include <condition_variable>
-#include "Common/Cpp/ListenerSet.h"
 #include "Common/Cpp/Concurrency/SpinLock.h"
 #include "Common/Cpp/Concurrency/Thread.h"
 #include "CommonFramework/Logging/Logger.h"
@@ -23,23 +22,14 @@ class QKeyEvent;
 namespace PokemonAutomation{
 
 
-class KeyboardHidTracker{
-public:
-    void add_listener(ControllerInputListener& listener){
-        m_listeners.add(listener);
-    }
-    void remove_listener(ControllerInputListener& listener){
-        m_listeners.remove(listener);
-    }
-
-
+class KeyboardHidTracker : public ControllerInputSource{
 public:
     ~KeyboardHidTracker();
     KeyboardHidTracker();
 
-    void stop();
+    virtual void stop() override;
 
-    void clear_state();
+    virtual void clear_state() override;
 
     void on_key_press(const QKeyEvent& key);
     void on_key_release(const QKeyEvent& key);
@@ -62,8 +52,6 @@ class KeyboardHidTracker{
     std::mutex m_sleep_lock;
     std::condition_variable m_cv;
     Thread m_thread;
-
-    ListenerSet<ControllerInputListener> m_listeners;
 };
 
 

SerialPrograms/Source/NintendoSwitch/Framework/UI/NintendoSwitch_CommandRow.cpp

@@ -10,6 +10,7 @@
 #include "CommonFramework/Options/Environment/ThemeSelectorOption.h"
 #include "CommonFramework/Panels/ConsoleSettingsStretch.h"
 #include "CommonFramework/Recording/StreamHistoryOption.h"
+#include "ControllerInput/ControllerInput.h"
 #include "ControllerInput/Keyboard/GlobalKeyboardHidTracker.h"
 #include "NintendoSwitch_CommandRow.h"
 
@@ -24,7 +25,7 @@ namespace NintendoSwitch{
 
 
 CommandRow::~CommandRow(){
-    global_keyboard_tracker().remove_listener(*this);
+    global_input_remove_listener(*this);
     m_controller.remove_listener(*this);
     m_session.remove_listener(*this);
 }
@@ -180,6 +181,10 @@ CommandRow::CommandRow(
     m_controller.add_listener(*this);
 }
 
+
+bool CommandRow::allow_controller_input() const{
+    return m_allow_commands_while_running || m_last_known_state == ProgramState::STOPPED;
+}
 void CommandRow::run_controller_input(ControllerInputState& state){
     if (!m_last_known_focus){
         m_controller.logger().log("Keyboard Command Suppressed: Not in focus.", COLOR_RED);
@@ -190,23 +195,23 @@ void CommandRow::run_controller_input(ControllerInputState& state){
         m_controller.logger().log("Keyboard Command Suppressed: Controller is null.", COLOR_RED);
         return;
     }
-    if (!m_allow_commands_while_running && m_last_known_state != ProgramState::STOPPED){
+    if (!allow_controller_input()){
         m_controller.logger().log("Keyboard Command Suppressed: Program is running.", COLOR_RED);
         return;
     }
     controller->run_controller_input(state);
 }
 void CommandRow::set_focus(bool focused){
     if (focused){
-        global_keyboard_tracker().add_listener(*this);
+        if (allow_controller_input()){
+            global_input_add_listener(*this);
+        }
     }else{
-        global_keyboard_tracker().clear_state();
-        global_keyboard_tracker().remove_listener(*this);
+        global_input_clear_state();
+        global_input_remove_listener(*this);
 
         AbstractController* controller = m_controller.controller();
-        if (controller != nullptr &&
-            (m_allow_commands_while_running || m_last_known_state == ProgramState::STOPPED)
-        ){
+        if (controller != nullptr && allow_controller_input()){
             controller->cancel_all_commands();
         }
     }
@@ -268,14 +273,11 @@ void CommandRow::update_ui(){
 
 void CommandRow::on_state_changed(ProgramState state){
     m_last_known_state = state;
-    if (m_allow_commands_while_running || state == ProgramState::STOPPED){
-        global_keyboard_tracker().clear_state();
-#if 0
-        AbstractController* controller = m_controller.controller();
-        if (controller != nullptr){
-            controller->keyboard_release_all();
-        }
-#endif
+    if (allow_controller_input()){
+        global_input_clear_state();
+        global_input_add_listener(*this);
+    }else{
+        global_input_remove_listener(*this);
     }
     update_ui();
 }

SerialPrograms/Source/NintendoSwitch/Framework/UI/NintendoSwitch_CommandRow.h

@@ -54,6 +54,8 @@ class CommandRow :
     void on_state_changed(ProgramState state);
 
 private:
+    bool allow_controller_input() const;
+
     virtual void run_controller_input(ControllerInputState& state) override;
 
     virtual void on_overlay_enabled_stats  (bool enabled) override;