Add infra to change controller types.

Author: Mysticial

SerialPrograms/Source/Controllers/ControllerDescriptor.cpp

@@ -41,8 +41,7 @@ void InterfaceType::register_factory(
 
 
 ControllerOption::ControllerOption()
-    : m_controller_type(ControllerType::None)
-    , m_descriptor(new NullControllerDescriptor())
+    : m_descriptor(new NullControllerDescriptor())
 {}
 
 
@@ -63,7 +62,6 @@ std::shared_ptr<const ControllerDescriptor> ControllerOption::get_descriptor_fro
 
 void ControllerOption::load_json(const JsonValue& json){
     std::shared_ptr<const ControllerDescriptor> descriptor;
-    ControllerType controller_type = ControllerType::None;
     do{
         if (json.is_null()){
             break;
@@ -77,10 +75,6 @@ void ControllerOption::load_json(const JsonValue& json){
         if (type == nullptr){
             break;
         }
-        const std::string* controller = obj->get_string("Controller");
-        if (controller != nullptr){
-            controller_type = CONTROLLER_TYPE_STRINGS.get_enum(*controller, ControllerType::None);
-        }
 
         for (const auto& item : ALL_CONTROLLER_INTERFACES){
             const JsonValue* params = obj->get_value(CONTROLLER_INTERFACE_STRINGS.get_string(item.first));
@@ -104,15 +98,13 @@ void ControllerOption::load_json(const JsonValue& json){
     }
 
     m_descriptor = std::move(descriptor);
-    m_controller_type = controller_type;
 }
 JsonValue ControllerOption::to_json() const{
     if (!m_descriptor){
         return JsonValue();
     }
     JsonObject obj;
     obj["Interface"] = CONTROLLER_INTERFACE_STRINGS.get_string(m_descriptor->interface_type);
-    obj["Controller"] = CONTROLLER_TYPE_STRINGS.get_string(m_controller_type);
 
     for (const auto& item : m_descriptor_cache){
         obj[CONTROLLER_INTERFACE_STRINGS.get_string(item.first)] = item.second->to_json();

SerialPrograms/Source/Controllers/ControllerDescriptor.h

@@ -7,6 +7,7 @@
 #ifndef PokemonAutomation_Controllers_ControllerDescriptor_H
 #define PokemonAutomation_Controllers_ControllerDescriptor_H
 
+#include <optional>
 #include <string>
 #include <memory>
 #include <map>
@@ -99,7 +100,10 @@ class ControllerDescriptor{
     virtual void load_json(const JsonValue& json) = 0;
     virtual JsonValue to_json() const = 0;
 
-    virtual std::unique_ptr<ControllerConnection> open_connection(Logger& logger) const = 0;
+    virtual std::unique_ptr<ControllerConnection> open_connection(
+        Logger& logger,
+        std::optional<ControllerType> change_controller
+    ) const = 0;
     virtual std::unique_ptr<AbstractController> make_controller(
         Logger& logger,
         ControllerConnection& connection,
@@ -140,9 +144,6 @@ class ControllerOption{
     JsonValue to_json() const;
 
 
-public:
-//    friend class ControllerSession;
-    ControllerType m_controller_type;
 private:
     std::shared_ptr<const ControllerDescriptor> m_descriptor;
 

SerialPrograms/Source/Controllers/ControllerSession.cpp

@@ -48,10 +48,10 @@ ControllerSession::ControllerSession(
     : m_logger(logger)
     , m_requirements(requirements)
     , m_option(option)
+    , m_controller_type(ControllerType::None)
     , m_options_locked(false)
-    , m_connection_is_shutting_down(false)
     , m_descriptor(option.descriptor())
-    , m_connection(m_descriptor->open_connection(logger))
+    , m_connection(m_descriptor->open_connection(logger, {}))
 {
     if (!m_connection){
         return;
@@ -102,7 +102,7 @@ std::shared_ptr<const ControllerDescriptor> ControllerSession::descriptor() cons
 }
 ControllerType ControllerSession::controller_type() const{
     std::lock_guard<std::mutex> lg(m_state_lock);
-    return m_option.m_controller_type;
+    return m_controller_type;
 }
 std::string ControllerSession::status_text() const{
     std::lock_guard<std::mutex> lg(m_state_lock);
@@ -166,13 +166,13 @@ void ControllerSession::set_options_locked(bool locked){
 }
 
 
-void ControllerSession::make_controller(){
+void ControllerSession::make_controller(std::optional<ControllerType> change_controller){
     //  Must be called under "m_reset_lock".
 
     bool ready = false;
     {
         std::lock_guard<std::mutex> lg(m_state_lock);
-        m_connection = m_descriptor->open_connection(m_logger);
+        m_connection = m_descriptor->open_connection(m_logger, change_controller);
         if (m_connection){
             m_connection->add_status_listener(*this);
             ready = m_connection->is_ready();
@@ -222,7 +222,7 @@ bool ControllerSession::set_device(const std::shared_ptr<const ControllerDescrip
         controller.reset();
         connection.reset();
 
-        make_controller();
+        make_controller({});
     }
     signal_descriptor_changed(device);
     signal_status_text_changed(status_text());
@@ -242,15 +242,15 @@ bool ControllerSession::set_controller(ControllerType controller_type){
             if (m_options_locked){
                 return false;
             }
-            if (m_option.m_controller_type == controller_type){
+            if (m_controller_type == controller_type){
                 return true;
             }
 
             //  Move these out to indicate that we should no longer access them.
             controller = std::move(m_controller);
             connection = std::move(m_connection);
 
-            m_option.m_controller_type = controller_type;
+            m_controller_type = controller_type;
         }
 
         //  With the lock released, it is now safe to destroy them.
@@ -259,7 +259,7 @@ bool ControllerSession::set_controller(ControllerType controller_type){
         controller.reset();
         connection.reset();
 
-        make_controller();
+        make_controller(controller_type);
         device = m_descriptor;
     }
     signal_descriptor_changed(device);
@@ -296,7 +296,7 @@ std::string ControllerSession::reset(){
         controller.reset();
         connection.reset();
 
-        make_controller();
+        make_controller(m_controller_type);
     }
     signal_status_text_changed(status_text());
     return "";
@@ -377,7 +377,7 @@ void ControllerSession::post_connection_ready(
 
         //  Commit all changes.
 //        cout << "current_controller = " << CONTROLLER_TYPE_STRINGS.get_string(current_controller) << endl;
-        m_option.m_controller_type = current_controller;
+        m_controller_type = current_controller;
         ready = m_controller && m_controller->is_ready();
 
         WriteSpinLock lg1(m_message_lock);

SerialPrograms/Source/Controllers/ControllerSession.h

@@ -118,7 +118,7 @@ class ControllerSession : private ControllerConnection::StatusListener{
 
 
 private:
-    void make_controller();
+    void make_controller(std::optional<ControllerType> change_controller);
 
 //    virtual void pre_connection_not_ready(ControllerConnection& connection) override;
     virtual void post_connection_ready(
@@ -150,12 +150,12 @@ class ControllerSession : private ControllerConnection::StatusListener{
     Logger& m_logger;
     const ControllerRequirements& m_requirements;
     ControllerOption& m_option;
+    ControllerType m_controller_type;
 
     std::mutex m_reset_lock;
     mutable std::mutex m_state_lock;
 
     bool m_options_locked;
-    std::atomic<bool> m_connection_is_shutting_down;
     std::string m_user_input_disallow_reason;
 
     SpinLock m_message_lock;

SerialPrograms/Source/Controllers/NullController.cpp

@@ -28,7 +28,10 @@ void NullControllerDescriptor::load_json(const JsonValue& json){
 JsonValue NullControllerDescriptor::to_json() const{
     return JsonValue();
 }
-std::unique_ptr<ControllerConnection> NullControllerDescriptor::open_connection(Logger& logger) const{
+std::unique_ptr<ControllerConnection> NullControllerDescriptor::open_connection(
+    Logger& logger,
+    std::optional<ControllerType> change_controller
+) const{
     return nullptr;
 }
 std::unique_ptr<AbstractController> NullControllerDescriptor::make_controller(

SerialPrograms/Source/Controllers/NullController.h

@@ -26,7 +26,10 @@ class NullControllerDescriptor : public ControllerDescriptor{
     virtual void load_json(const JsonValue& json) override;
     virtual JsonValue to_json() const override;
 
-    virtual std::unique_ptr<ControllerConnection> open_connection(Logger& logger) const override;
+    virtual std::unique_ptr<ControllerConnection> open_connection(
+        Logger& logger,
+        std::optional<ControllerType> change_controller
+    ) const override;
     virtual std::unique_ptr<AbstractController> make_controller(
         Logger& logger,
         ControllerConnection& connection,

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase.cpp

@@ -31,7 +31,7 @@ std::string program_name(uint8_t id){
     default: return "Unknown ID";
     }
 }
-ControllerType controller_type(uint32_t id){
+ControllerType id_to_controller_type(uint32_t id){
     switch (id){
     case PABB_CID_NONE:
         return ControllerType::None;
@@ -47,6 +47,20 @@ ControllerType controller_type(uint32_t id){
         return ControllerType::None;
     }
 }
+uint32_t controller_type_to_id(ControllerType controller_type){
+    switch (controller_type){
+    case ControllerType::NintendoSwitch_WiredProController:
+        return PABB_CID_NINTENDO_SWITCH_WIRED_PRO_CONTROLLER;
+    case ControllerType::NintendoSwitch_WirelessProController:
+        return PABB_CID_NINTENDO_SWITCH_WIRELESS_PRO_CONTROLLER;
+    case ControllerType::NintendoSwitch_LeftJoycon:
+        return PABB_CID_NINTENDO_SWITCH_LEFT_JOYCON;
+    case ControllerType::NintendoSwitch_RightJoycon:
+        return PABB_CID_NINTENDO_SWITCH_RIGHT_JOYCON;
+    default:
+        return PABB_CID_NONE;
+    }
+}
 
 
 

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase.h

@@ -24,7 +24,8 @@ extern const ControllerRequirements OLD_NINTENDO_SWITCH_DEFAULT_REQUIREMENTS;
 
 
 std::string program_name(uint8_t id);
-ControllerType controller_type(uint32_t id);
+ControllerType id_to_controller_type(uint32_t id);
+uint32_t controller_type_to_id(ControllerType controller_type);
 
 
 

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.cpp

@@ -10,6 +10,7 @@
 #include "Common/Cpp/Exceptions.h"
 #include "Common/Cpp/PanicDump.h"
 #include "Common/Microcontroller/DeviceRoutines.h"
+#include "Common/PokemonSwSh/PokemonProgramIDs.h"
 #include "ClientSource/Libraries/MessageConverter.h"
 #include "ClientSource/Connection/SerialConnection.h"
 #include "ClientSource/Connection/PABotBase.h"
@@ -32,7 +33,8 @@ namespace SerialPABotBase{
 
 SerialPABotBase_Connection::SerialPABotBase_Connection(
     Logger& logger,
-    const QSerialPortInfo* port
+    const QSerialPortInfo* port,
+    std::optional<ControllerType> change_controller
 )
     : m_logger(logger, GlobalSettings::instance().LOG_EVERYTHING)
 {
@@ -78,7 +80,11 @@ SerialPABotBase_Connection::SerialPABotBase_Connection(
         return;
     }
 
-    m_status_thread = std::thread(run_with_catch, "SerialPABotBase_Connection::thread_body()", [this]{ thread_body(); });
+    m_status_thread = std::thread(
+        run_with_catch,
+        "SerialPABotBase_Connection::thread_body()",
+        [=, this]{ thread_body(change_controller); }
+    );
 }
 SerialPABotBase_Connection::~SerialPABotBase_Connection(){
     m_ready.store(false, std::memory_order_release);
@@ -144,7 +150,9 @@ ControllerModeStatus SerialPABotBase_Connection::controller_mode_status() const{
 }
 
 
-ControllerModeStatus SerialPABotBase_Connection::read_device_specs(){
+ControllerModeStatus SerialPABotBase_Connection::read_device_specs(
+    std::optional<ControllerType> change_controller
+){
     Logger& logger = m_logger;
 
 
@@ -196,16 +204,34 @@ ControllerModeStatus SerialPABotBase_Connection::read_device_specs(){
         current_controller = program_iter->second.begin()->first;
     }else if (program_iter->second.size() > 1){
         uint32_t type_id = Microcontroller::read_controller_mode(*m_botbase);
-        current_controller = controller_type(type_id);
+        current_controller = id_to_controller_type(type_id);
     }
     logger.log("Reading Controller Mode... Mode = " + CONTROLLER_TYPE_STRINGS.get_string(current_controller));
 
+
+    if (change_controller && program_iter->second.size() > 1){
+        ControllerType desired_controller = change_controller.value();
+        uint32_t native_controller_id = controller_type_to_id(desired_controller);
+        m_botbase->issue_request_and_wait(
+            Microcontroller::DeviceRequest_change_controller_mode(native_controller_id),
+            nullptr
+        );
+
+        //  Re-read the controller.
+        logger.log("Reading Controller Mode...");
+        uint32_t type_id = Microcontroller::read_controller_mode(*m_botbase);
+        current_controller = id_to_controller_type(type_id);
+        logger.log("Reading Controller Mode... Mode = " + CONTROLLER_TYPE_STRINGS.get_string(current_controller));
+    }
+
     return {current_controller, program_iter->second};
 }
 
 
 
-void SerialPABotBase_Connection::thread_body(){
+void SerialPABotBase_Connection::thread_body(
+    std::optional<ControllerType> change_controller
+){
     using namespace PokemonAutomation;
 
     m_botbase->set_sniffer(&m_logger);
@@ -236,7 +262,7 @@ void SerialPABotBase_Connection::thread_body(){
         ControllerModeStatus mode_status;
         std::string error;
         try{
-            mode_status = read_device_specs();
+            mode_status = read_device_specs(change_controller);
             std::lock_guard<std::mutex> lg(m_lock);
             m_mode_status = mode_status;
 

SerialPrograms/Source/Controllers/SerialPABotBase/SerialPABotBase_Connection.h

@@ -26,7 +26,8 @@ class SerialPABotBase_Connection : public ControllerConnection{
 public:
     SerialPABotBase_Connection(
         Logger& logger,
-        const QSerialPortInfo* port
+        const QSerialPortInfo* port,
+        std::optional<ControllerType> change_controller
     );
     ~SerialPABotBase_Connection();
 
@@ -42,9 +43,13 @@ class SerialPABotBase_Connection : public ControllerConnection{
 
 
 private:
-    ControllerModeStatus read_device_specs();
+    ControllerModeStatus read_device_specs(
+        std::optional<ControllerType> change_controller
+    );
 
-    void thread_body();
+    void thread_body(
+        std::optional<ControllerType> change_controller
+    );
 
 
 private: