Refactor: Separate connection and controller.

Author: Mysticial

SerialPrograms/CMakeLists.txt

@@ -610,6 +610,7 @@ file(GLOB MAIN_SOURCES
     Source/ComputerPrograms/Framework/ComputerProgramWidget.cpp
     Source/ComputerPrograms/Framework/ComputerProgramWidget.h
     Source/Controllers/Controller.h
+    Source/Controllers/ControllerCapability.cpp
     Source/Controllers/ControllerCapability.h
     Source/Controllers/ControllerDescriptor.cpp
     Source/Controllers/ControllerDescriptor.h

SerialPrograms/SerialPrograms.pro

@@ -310,6 +310,7 @@ SOURCES += \
     Source/ComputerPrograms/Framework/ComputerProgramOption.cpp \
     Source/ComputerPrograms/Framework/ComputerProgramSession.cpp \
     Source/ComputerPrograms/Framework/ComputerProgramWidget.cpp \
+    Source/Controllers/ControllerCapability.cpp \
     Source/Controllers/ControllerConnection.cpp \
     Source/Controllers/ControllerSelectorWidget.cpp \
     Source/Controllers/ControllerSession.cpp \

SerialPrograms/Source/Controllers/Controller.h

@@ -7,15 +7,23 @@
 #ifndef PokemonAutomation_Controllers_Controller_H
 #define PokemonAutomation_Controllers_Controller_H
 
+#include <string>
 #include "Common/Compiler.h"
 
 class QKeyEvent;
 
 namespace PokemonAutomation{
 
 
-class Controller{
+class AbstractController{
 public:
+    virtual ~AbstractController() = default;
+
+    virtual bool is_ready() const = 0;
+    virtual std::string error_string() const = 0;
+
+public:
+    //  Keyboard Controls
     virtual void keyboard_release_all(){}
     virtual void keyboard_press(const QKeyEvent& event){}
     virtual void keyboard_release(const QKeyEvent& event){}

SerialPrograms/Source/Controllers/ControllerCapability.cpp

@@ -0,0 +1,48 @@
+/*  Controller Capabilities
+ *
+ *  From: https://github.com/PokemonAutomation/Arduino-Source
+ *
+ */
+
+#include "ControllerCapability.h"
+
+namespace PokemonAutomation{
+
+
+const char* to_string(ControllerType type){
+    switch (type){
+    case ControllerType::NintendoSwitch_WiredProController:
+        return "NintendoSwitch_WiredProController";
+    case ControllerType::NintendoSwitch_WirelessProController:
+        return "NintendoSwitch_WirelessProController";
+    case ControllerType::NintendoSwitch_LeftJoycon:
+        return "NintendoSwitch_LeftJoycon";
+    case ControllerType::NintendoSwitch_RightJoycon:
+        return "NintendoSwitch_RightJoycon";
+    }
+    return nullptr;
+}
+
+
+
+const char* to_string(ControllerFeature feature){
+    switch (feature){
+    case ControllerFeature::TickPrecise:
+        return "TickPrecise";
+    case ControllerFeature::QueryTickSize:
+        return "QueryTickSize";
+    case ControllerFeature::QueryCommandQueueSize:
+        return "QueryCommandQueueSize";
+    case ControllerFeature::NintendoSwitch_ProController:
+        return "NintendoSwitch_ProController";
+    case ControllerFeature::NintendoSwitch_DateSkip:
+        return "NintendoSwitch_DateSkip";
+    }
+    return nullptr;
+}
+
+
+
+
+
+}

SerialPrograms/Source/Controllers/ControllerCapability.h

@@ -30,6 +30,34 @@
 namespace PokemonAutomation{
 
 
+
+enum class ControllerInterface{
+    SerialPABotBase,
+};
+
+
+enum class ControllerType{
+    None,
+    NintendoSwitch_WiredProController,
+    NintendoSwitch_WirelessProController,
+    NintendoSwitch_LeftJoycon,
+    NintendoSwitch_RightJoycon,
+};
+const char* to_string(ControllerType type);
+
+
+enum class ControllerFeature{
+    TickPrecise,
+    QueryTickSize,
+    QueryCommandQueueSize,
+    NintendoSwitch_ProController,
+    NintendoSwitch_DateSkip,
+};
+const char* to_string(ControllerFeature feature);
+
+
+
+
 //
 //  This class is a double map.
 //  The first level is keyed on a string representing the interface type. (serial, bluetooth, etc...)
@@ -44,12 +72,12 @@ namespace PokemonAutomation{
 //
 class ControllerRequirements{
 public:
-    ControllerRequirements(std::initializer_list<std::map<std::string, std::set<std::string>>::value_type> args)
+    ControllerRequirements(std::initializer_list<std::map<std::string, std::set<ControllerFeature>>::value_type> args)
         : m_map(std::move(args))
         , m_sanitizer("ControllerRequirements")
     {}
 
-    const std::map<std::string, std::set<std::string>>& map() const{
+    const std::map<std::string, std::set<ControllerFeature>>& map() const{
         auto scope_check = m_sanitizer.check_scope();
         return m_map;
     }
@@ -61,26 +89,26 @@ class ControllerRequirements{
 
     //  Check compatibility. If compatible, returns empty string.
     //  Otherwise returns one of the missing features.
-    std::string check_compatibility(const std::string& device, const std::set<std::string>& features) const{
+    std::string check_compatibility(const std::string& device, const std::set<ControllerFeature>& features) const{
         auto scope_check = m_sanitizer.check_scope();
 
         auto iter0 = m_map.find(device);
         if (iter0 == m_map.end()){
             return device;
         }
 
-        const std::set<std::string>& required = iter0->second;
-        for (const std::string& feature : required){
+        const std::set<ControllerFeature>& required = iter0->second;
+        for (ControllerFeature feature : required){
             if (features.find(feature) == features.end()){
-                return feature;
+                return to_string(feature);
             }
         }
         return "";
     }
 
 
 private:
-    std::map<std::string, std::set<std::string>> m_map;
+    std::map<std::string, std::set<ControllerFeature>> m_map;
 
     LifetimeSanitizer m_sanitizer;
 };

SerialPrograms/Source/Controllers/ControllerConnection.cpp

@@ -16,6 +16,9 @@ namespace PokemonAutomation{
 
 void ControllerConnection::add_status_listener(StatusListener& listener){
     m_status_listeners.add(listener);
+    if (m_ready.load(std::memory_order_acquire)){
+        listener.post_ready(supported_controllers());
+    }
 }
 void ControllerConnection::remove_status_listener(StatusListener& listener){
     m_status_listeners.remove(listener);
@@ -39,8 +42,8 @@ void ControllerConnection::set_status(const std::string& text){
 void ControllerConnection::signal_pre_not_ready(){
     m_status_listeners.run_method_unique(&StatusListener::pre_not_ready);
 }
-void ControllerConnection::signal_post_ready(const std::set<std::string>& capabilities){
-    m_status_listeners.run_method_unique(&StatusListener::post_ready, capabilities);
+void ControllerConnection::signal_post_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers){
+    m_status_listeners.run_method_unique(&StatusListener::post_ready, controllers);
 }
 void ControllerConnection::signal_status_text_changed(const std::string& text){
 //    cout << "m_status_listeners.size() = " << m_status_listeners.count_unique() << endl;

SerialPrograms/Source/Controllers/ControllerConnection.h

@@ -19,7 +19,7 @@ class ControllerConnection{
 public:
     struct StatusListener{
         virtual void pre_not_ready(){}
-        virtual void post_ready(const std::set<std::string>& capabilities){}
+        virtual void post_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers){}
         virtual void post_status_text_changed(const std::string& text){}
     };
 
@@ -30,22 +30,23 @@ class ControllerConnection{
 public:
     virtual ~ControllerConnection() = default;
 
-    bool ready() const{ return m_ready.load(std::memory_order_acquire); }
+    bool is_ready() const{ return m_ready.load(std::memory_order_acquire); }
     std::string status_text() const;
 
+    virtual std::map<ControllerType, std::set<ControllerFeature>> supported_controllers() const = 0;
+
 
 protected:
     void set_status(const std::string& text);
 
     void signal_pre_not_ready();
-    void signal_post_ready(const std::set<std::string>& capabilities);
+    void signal_post_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers);
     void signal_status_text_changed(const std::string& text);
 
 
 protected:
     std::atomic<bool> m_ready;
 
-
 private:
     mutable SpinLock m_status_text_lock;
     std::string m_status_text;

SerialPrograms/Source/Controllers/ControllerDescriptor.cpp

@@ -22,12 +22,12 @@ namespace PokemonAutomation{
 //
 //  Here we store a map of all controller types in the program.
 //
-std::map<std::string, std::unique_ptr<ControllerType>> CONTROLLER_TYPES;
+std::map<std::string, std::unique_ptr<AbstractControllerType>> CONTROLLER_TYPES;
 
 
-void ControllerType::register_factory(
+void AbstractControllerType::register_factory(
     const std::string& name,
-    std::unique_ptr<ControllerType> factory
+    std::unique_ptr<AbstractControllerType> factory
 ){
     auto ret = CONTROLLER_TYPES.emplace(name, std::move(factory));
     if (!ret.second){

SerialPrograms/Source/Controllers/ControllerDescriptor.h

@@ -10,12 +10,14 @@
 #include <string>
 #include <memory>
 #include "Common/Cpp/AbstractLogger.h"
+#include "ControllerCapability.h"
+#include "Controller.h"
 
 namespace PokemonAutomation{
 
 class JsonValue;
 class ControllerRequirements;
-class ControllerType;
+class AbstractControllerType;
 class ControllerDescriptor;
 class ControllerConnection;
 
@@ -25,14 +27,14 @@ class ControllerConnection;
 //
 //  For example:
 //      -   "Nintendo Switch via Serial PABotBase" is a type of controller.
-//      -   "Nintendo Switch via Joycon Emulatiion" is a type of controller. (hypothetical)
+//      -   "Nintendo Switch via Joycon Emulation" is a type of controller. (hypothetical)
 //      -   "Xbox One via whatever..." ...
 //
 //  One instance of this class exists for each type of controller.
 //
-class ControllerType{
+class AbstractControllerType{
 public:
-    virtual ~ControllerType() = default;
+    virtual ~AbstractControllerType() = default;
 
     //  Returns a list of all available instances for this controller type.
     virtual std::vector<std::shared_ptr<const ControllerDescriptor>> list() const = 0;
@@ -43,7 +45,7 @@ class ControllerType{
 protected:
     static void register_factory(
         const std::string& name,
-        std::unique_ptr<ControllerType> factory
+        std::unique_ptr<AbstractControllerType> factory
     );
 };
 
@@ -52,7 +54,7 @@ class ControllerType{
 //  Subclass helper for ControllerType.
 //
 template <typename DescriptorType>
-class ControllerType_t : public ControllerType{
+class ControllerType_t : public AbstractControllerType{
 public:
     //  Subclasses must implement this function.
     virtual std::vector<std::shared_ptr<const ControllerDescriptor>> list() const override;
@@ -66,7 +68,7 @@ class ControllerType_t : public ControllerType{
 
 private:
     static int register_class(){
-        ControllerType::register_factory(
+        AbstractControllerType::register_factory(
             DescriptorType::TYPENAME,
             std::make_unique<ControllerType_t<DescriptorType>>()
         );
@@ -96,11 +98,17 @@ class ControllerDescriptor{
     virtual void load_json(const JsonValue& json) = 0;
     virtual JsonValue to_json() const = 0;
 
-    virtual std::unique_ptr<ControllerConnection> open(Logger& logger) const = 0;
-    virtual std::unique_ptr<ControllerConnection> open(
+    virtual std::unique_ptr<ControllerConnection> open_connection(
+        Logger& logger
+    ) const = 0;
+    virtual std::unique_ptr<AbstractController> make_controller(
         Logger& logger,
+        ControllerConnection& connection,
+        ControllerType controller_type,
         const ControllerRequirements& requirements
-    ) const = 0;
+    ) const{
+        return nullptr;
+    }
 };