Refactor controller descriptors.

Author: Mysticial

SerialPrograms/CMakeLists.txt

@@ -635,8 +635,8 @@ file(GLOB MAIN_SOURCES
     Source/Controllers/SerialPABotBase/SerialPABotBase.h
     Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.cpp
     Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.h
-    Source/Controllers/SerialPABotBase/SerialPABotBase_Interface.cpp
-    Source/Controllers/SerialPABotBase/SerialPABotBase_Interface.h
+    Source/Controllers/SerialPABotBase/SerialPABotBase_Descriptor.cpp
+    Source/Controllers/SerialPABotBase/SerialPABotBase_Descriptor.h
     Source/Integrations/DiscordIntegrationSettings.cpp
     Source/Integrations/DiscordIntegrationSettings.h
     Source/Integrations/DiscordIntegrationTable.cpp

SerialPrograms/SerialPrograms.pro

@@ -321,7 +321,7 @@ SOURCES += \
     Source/Controllers/NullController.cpp \
     Source/Controllers/SerialPABotBase/SerialPABotBase.cpp \
     Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.cpp \
-    Source/Controllers/SerialPABotBase/SerialPABotBase_Interface.cpp \
+    Source/Controllers/SerialPABotBase/SerialPABotBase_Descriptor.cpp \
     Source/Controllers/SuperscalarScheduler.cpp \
     Source/Integrations/DiscordIntegrationSettings.cpp \
     Source/Integrations/DiscordIntegrationTable.cpp \
@@ -1457,7 +1457,7 @@ HEADERS += \
     Source/Controllers/NullController.h \
     Source/Controllers/SerialPABotBase/SerialPABotBase.h \
     Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.h \
-    Source/Controllers/SerialPABotBase/SerialPABotBase_Interface.h \
+    Source/Controllers/SerialPABotBase/SerialPABotBase_Descriptor.h \
     Source/Controllers/SuperscalarScheduler.h \
     Source/Integrations/DiscordIntegrationSettings.h \
     Source/Integrations/DiscordIntegrationTable.h \

SerialPrograms/Source/CommonFramework/Panels/UI/PanelListWidget.cpp

@@ -86,7 +86,9 @@ void PanelListWidget::handle_panel_clicked(const std::string& text){
     }
     try{
         std::unique_ptr<PanelInstance> panel = descriptor->make_panel();
-        panel->from_json(PERSISTENT_SETTINGS().panels[descriptor->identifier()]);
+//        try{
+            panel->from_json(PERSISTENT_SETTINGS().panels[descriptor->identifier()]);
+//        }catch (ParseException&){}
         m_panel_holder.load_panel(descriptor, std::move(panel));
 
         PERSISTENT_SETTINGS().panels[JSON_PROGRAM_PANEL] = iter->first;

SerialPrograms/Source/Controllers/ControllerCapability.cpp

@@ -11,6 +11,7 @@ namespace PokemonAutomation{
 
 
 const EnumStringMap<ControllerInterface> CONTROLLER_INTERFACE_STRINGS{
+    {ControllerInterface::None,                 "None"},
     {ControllerInterface::SerialPABotBase,      "SerialPABotBase"},
 };
 

SerialPrograms/Source/Controllers/ControllerCapability.h

@@ -32,8 +32,8 @@ namespace PokemonAutomation{
 
 
 
-
 enum class ControllerInterface{
+    None,
     SerialPABotBase,
 };
 extern const EnumStringMap<ControllerInterface> CONTROLLER_INTERFACE_STRINGS;
@@ -61,6 +61,8 @@ extern const EnumStringMap<ControllerFeature> CONTROLLER_FEATURE_STRINGS;
 
 
 
+
+
 class ControllerRequirements{
 public:
     ControllerRequirements(std::initializer_list<ControllerFeature> args);

SerialPrograms/Source/Controllers/ControllerDescriptor.cpp

@@ -22,16 +22,19 @@ namespace PokemonAutomation{
 //
 //  Here we store a map of all controller types in the program.
 //
-std::map<std::string, std::unique_ptr<AbstractControllerType>> CONTROLLER_TYPES;
+std::map<ControllerInterface, std::unique_ptr<InterfaceType>> ALL_CONTROLLER_INTERFACES;
 
 
-void AbstractControllerType::register_factory(
-    const std::string& name,
-    std::unique_ptr<AbstractControllerType> factory
+void InterfaceType::register_factory(
+    ControllerInterface controller_interface,
+    std::unique_ptr<InterfaceType> factory
 ){
-    auto ret = CONTROLLER_TYPES.emplace(name, std::move(factory));
+    auto ret = ALL_CONTROLLER_INTERFACES.emplace(controller_interface, std::move(factory));
     if (!ret.second){
-        throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "Duplicate Factory Name: " + name);
+        throw InternalProgramError(
+            nullptr, PA_CURRENT_FUNCTION,
+            "Duplicate Factory Name: " + CONTROLLER_INTERFACE_STRINGS.get_string(controller_interface)
+        );
     }
 }
 
@@ -45,8 +48,8 @@ get_compatible_descriptors(const ControllerRequirements& requirements){
     ret.emplace_back(new NullControllerDescriptor());
 
     //  Add all other controllers. We don't filter them at this time.
-    for (const auto& controller_interface : CONTROLLER_TYPES){
-        if (controller_interface.first == NullControllerDescriptor::TYPENAME){
+    for (const auto& controller_interface : ALL_CONTROLLER_INTERFACES){
+        if (controller_interface.first == ControllerInterface::None){
             continue;
         }
         std::vector<std::shared_ptr<const ControllerDescriptor>> list = controller_interface.second->list();
@@ -58,8 +61,8 @@ get_compatible_descriptors(const ControllerRequirements& requirements){
     //  required list. For each of those, enumerate all the descriptors and
     //  combine them into a single list.
     for (const auto& device : requirements.map()){
-        auto iter = CONTROLLER_TYPES.find(device.first);
-        if (iter != CONTROLLER_TYPES.end()){
+        auto iter = ALL_CONTROLLER_INTERFACES.find(device.first);
+        if (iter != ALL_CONTROLLER_INTERFACES.end()){
             std::vector<std::shared_ptr<const ControllerDescriptor>> list = iter->second->list();
             std::move(list.begin(), list.end(), std::back_inserter(ret));
         }
@@ -76,32 +79,60 @@ get_compatible_descriptors(const ControllerRequirements& requirements){
 
 
 ControllerOption::ControllerOption()
-    : m_current(new NullControllerDescriptor())
+    : m_descriptor(new NullControllerDescriptor())
+    , m_controller_type(ControllerType::None)
 {}
 
 void ControllerOption::load_json(const JsonValue& json){
-    if (json.is_null()){
-        m_current.reset(new NullControllerDescriptor());
-    }
-    const JsonObject& obj = json.to_object_throw();
-    const std::string& type = obj.get_string_throw("DeviceType");
-    const JsonValue& params = obj.get_value_throw("Parameters");
-
-    auto iter = CONTROLLER_TYPES.find(type);
-    if (iter == CONTROLLER_TYPES.end()){
-        m_current.reset(new NullControllerDescriptor());
-        return;
+    std::unique_ptr<const ControllerDescriptor> descriptor;
+    ControllerType controller_type = ControllerType::None;
+    do{
+        if (json.is_null()){
+            break;
+        }
+
+        const JsonObject* obj = json.to_object();
+        if (obj == nullptr){
+            break;
+        }
+        const std::string* type = obj->get_string("Interface");
+        if (type == nullptr){
+            break;
+        }
+        const std::string* controller = obj->get_string("Controller");
+        if (controller != nullptr){
+            controller_type = CONTROLLER_TYPE_STRINGS.get_enum(*controller);
+        }
+        const JsonValue* params = obj->get_value("Parameters");
+        if (params == nullptr){
+            break;
+        }
+
+        auto iter = ALL_CONTROLLER_INTERFACES.find(CONTROLLER_INTERFACE_STRINGS.get_enum(*type, ControllerInterface::None));
+        if (iter == ALL_CONTROLLER_INTERFACES.end()){
+            break;
+        }
+
+        descriptor = iter->second->make(*params);
+
+    }while (false);
+
+    if (descriptor == nullptr){
+        descriptor.reset(new NullControllerDescriptor());
     }
 
-    m_current = iter->second->make(params);
+    m_descriptor = std::move(descriptor);
+    m_controller_type = controller_type;
 }
 JsonValue ControllerOption::to_json() const{
-    if (!m_current){
+    if (!m_descriptor){
         return JsonValue();
     }
+
     JsonObject obj;
-    obj["DeviceType"] = m_current->type_name();
-    obj["Parameters"] = m_current->to_json();
+    obj["Interface"] = CONTROLLER_INTERFACE_STRINGS.get_string(m_descriptor->interface_type);
+    obj["Controller"] = CONTROLLER_TYPE_STRINGS.get_string(m_controller_type);
+    obj["Parameters"] = m_descriptor->to_json();
     return obj;
 }
 

SerialPrograms/Source/Controllers/ControllerDescriptor.h

@@ -16,35 +16,35 @@
 namespace PokemonAutomation{
 
 class JsonValue;
-class AbstractControllerType;
+class InterfaceType;
 class ControllerDescriptor;
 class ControllerConnection;
 
 
 //
-//  Represents an entire type of controller.
+//  Represents an entire controller interface.
 //
 //  For example:
-//      -   "Nintendo Switch via Serial PABotBase" is a type of controller.
-//      -   "Nintendo Switch via Joycon Emulation" is a type of controller. (hypothetical)
-//      -   "Xbox One via whatever..." ...
+//      -   Serial PABotBase
+//      -   Direct USB to X (hypothetical)
+//      -   Emulator IPC (hypothetical)
 //
-//  One instance of this class exists for each type of controller.
+//  One instance of this class exists for each interface.
 //
-class AbstractControllerType{
+class InterfaceType{
 public:
-    virtual ~AbstractControllerType() = default;
+    virtual ~InterfaceType() = default;
 
-    //  Returns a list of all available instances for this controller type.
+    //  Returns a list of all available descriptors for this interface type.
     virtual std::vector<std::shared_ptr<const ControllerDescriptor>> list() const = 0;
 
     //  Construct a descriptor from a JSON config. (reloading saved controller settings)
     virtual std::unique_ptr<ControllerDescriptor> make(const JsonValue& json) const = 0;
 
 protected:
     static void register_factory(
-        const std::string& name,
-        std::unique_ptr<AbstractControllerType> factory
+        ControllerInterface controller_interface,
+        std::unique_ptr<InterfaceType> factory
     );
 };
 
@@ -53,7 +53,7 @@ class AbstractControllerType{
 //  Subclass helper for ControllerType.
 //
 template <typename DescriptorType>
-class ControllerType_t : public AbstractControllerType{
+class InterfaceType_t : public InterfaceType{
 public:
     //  Subclasses must implement this function.
     virtual std::vector<std::shared_ptr<const ControllerDescriptor>> list() const override;
@@ -67,16 +67,16 @@ class ControllerType_t : public AbstractControllerType{
 
 private:
     static int register_class(){
-        AbstractControllerType::register_factory(
-            DescriptorType::TYPENAME,
-            std::make_unique<ControllerType_t<DescriptorType>>()
+        InterfaceType::register_factory(
+            DescriptorType::INTERFACE_NAME,
+            std::make_unique<InterfaceType_t<DescriptorType>>()
         );
         return 0;
     }
     static int initializer;
 };
 template <typename DescriptorType>
-int ControllerType_t<DescriptorType>::initializer = register_class();
+int InterfaceType_t<DescriptorType>::initializer = register_class();
 
 
 
@@ -88,10 +88,14 @@ int ControllerType_t<DescriptorType>::initializer = register_class();
 //
 class ControllerDescriptor{
 public:
+    const ControllerInterface interface_type;
+
+    ControllerDescriptor(ControllerInterface p_interface_type)
+        : interface_type(p_interface_type)
+    {}
     virtual ~ControllerDescriptor() = default;
     virtual bool operator==(const ControllerDescriptor& x) const = 0;
 
-    virtual const char* type_name() const = 0;
     virtual std::string display_name() const = 0;
 
     virtual void load_json(const JsonValue& json) = 0;
@@ -108,6 +112,7 @@ class ControllerDescriptor{
     ) const{
         return nullptr;
     }
+
 };
 
 
@@ -128,16 +133,17 @@ class ControllerOption{
 public:
     ControllerOption();
 
-    std::shared_ptr<const ControllerDescriptor> current() const{
-        return m_current;
+    std::shared_ptr<const ControllerDescriptor> descriptor() const{
+        return m_descriptor;
     }
 
     void load_json(const JsonValue& json);
     JsonValue to_json() const;
 
 private:
     friend class ControllerSession;
-    std::shared_ptr<const ControllerDescriptor> m_current;
+    std::shared_ptr<const ControllerDescriptor> m_descriptor;
+    ControllerType m_controller_type;
 };
 
 

SerialPrograms/Source/Controllers/ControllerSession.cpp

@@ -7,10 +7,9 @@
 #include "Common/Cpp/Exceptions.h"
 #include "ControllerSession.h"
 
-//  REMOVE
-#include <iostream>
-using std::cout;
-using std::endl;
+//#include <iostream>
+//using std::cout;
+//using std::endl;
 
 namespace PokemonAutomation{
 
@@ -42,7 +41,7 @@ ControllerSession::ControllerSession(
     , m_requirements(requirements)
     , m_option(option)
     , m_options_locked(false)
-    , m_descriptor(option.current())
+    , m_descriptor(option.descriptor())
     , m_connection(m_descriptor->open_connection(logger))
 {
 //    cout << "ControllerSession:ControllerSession(): " << m_descriptor->display_name() << endl;
@@ -58,7 +57,7 @@ void ControllerSession::get(ControllerOption& option){
     option = m_option;
 }
 void ControllerSession::set(const ControllerOption& option){
-    set_device(option.current());
+    set_device(option.descriptor());
 }
 
 
@@ -155,7 +154,7 @@ bool ControllerSession::set_device(const std::shared_ptr<const ControllerDescrip
             m_connection->add_status_listener(*this);
         }
 
-        m_option.m_current = device;
+        m_option.m_descriptor = device;
         m_descriptor = device;
     }
     signal_controller_changed(device);
@@ -191,21 +190,32 @@ void ControllerSession::pre_not_ready(){
     m_listeners.run_method_unique(&Listener::pre_not_ready);
 }
 void ControllerSession::post_ready(const std::map<ControllerType, std::set<ControllerFeature>>& controllers){
-#if 1
     if (controllers.empty()){
         return;
     }
 
-    //  REMOVE: TODO: Pick the first controller for now.
     auto iter = controllers.begin();
 
+    if (controllers.size() == 1){
+        //  Only one controller available. Force the option to it.
+        m_option.m_controller_type = iter->first;
+    }else{
+        //  Otherwise, try to use the option setting. If it's not valid,
+        //  clear it.
+        iter = controllers.find(m_option.m_controller_type);
+        if (iter == controllers.end()){
+            m_option.m_controller_type = ControllerType::None;
+            m_controller.reset();
+            return;
+        }
+    }
+
 //    cout << "post_ready()" << endl;
 
     m_controller.reset();
     m_controller = m_descriptor->make_controller(m_logger, *m_connection, iter->first, m_requirements);
     m_listeners.run_method_unique(&Listener::post_ready, controllers);
     signal_ready_changed(m_controller->is_ready());
-#endif
 }
 void ControllerSession::post_status_text_changed(const std::string& text){
     do{