Add preliminary SBB support.

Author: Mysticial

SerialPrograms/Source/Controllers/ControllerDescriptor.cpp

@@ -4,18 +4,16 @@
  *
  */
 
-#include <iterator>
 #include "Common/Cpp/Exceptions.h"
 #include "Common/Cpp/Json/JsonValue.h"
 #include "Common/Cpp/Json/JsonObject.h"
 #include "ControllerCapability.h"
 #include "ControllerDescriptor.h"
 #include "NullController.h"
 
-//  REMOVE
-#include <iostream>
-using std::cout;
-using std::endl;
+//#include <iostream>
+//using std::cout;
+//using std::endl;
 
 namespace PokemonAutomation{
 
@@ -41,44 +39,6 @@ void InterfaceType::register_factory(
 
 
 
-#if 0
-std::vector<std::shared_ptr<const ControllerDescriptor>>
-get_compatible_descriptors(const ControllerRequirements& requirements){
-    std::vector<std::shared_ptr<const ControllerDescriptor>> ret;
-
-    //  Null controller goes first.
-    ret.emplace_back(new NullControllerDescriptor());
-
-    //  Add all other controllers. We don't filter them at this time.
-    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();
-        std::move(list.begin(), list.end(), std::back_inserter(ret));
-    }
-
-#if 0
-    //  Find all the devices in common between the supported list and the
-    //  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 = 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));
-        }
-    }
-#endif
-
-    return ret;
-}
-#endif
-
-
-
-
-
 
 ControllerOption::ControllerOption()
     : m_controller_type(ControllerType::None)
@@ -130,11 +90,6 @@ void ControllerOption::load_json(const JsonValue& json){
             m_descriptor_cache[item.first] = item.second->make(*params);
         }
 
-//        const JsonValue* params = obj->get_value("Parameters");
-//        if (params == nullptr){
-//            break;
-//        }
-
         auto iter = m_descriptor_cache.find(CONTROLLER_INTERFACE_STRINGS.get_enum(*type, ControllerInterface::None));
         if (iter == m_descriptor_cache.end()){
             break;
@@ -158,7 +113,6 @@ JsonValue ControllerOption::to_json() const{
     JsonObject obj;
     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();
 
     for (const auto& item : m_descriptor_cache){
         obj[CONTROLLER_INTERFACE_STRINGS.get_string(item.first)] = item.second->to_json();

SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.cpp

@@ -65,10 +65,10 @@ class ProController::KeyboardManager : public KeyboardInputController{
         deltas.to_state(static_cast<SwitchControllerState&>(state));
     }
     virtual void cancel_all_commands() override{
-        m_controller.cancel_all_commands(nullptr);
+        m_controller.cancel_all_commands();
     }
     virtual void replace_on_next_command() override{
-        m_controller.replace_on_next_command(nullptr);
+        m_controller.replace_on_next_command();
     }
     virtual void send_state(const ControllerState& state) override{
         const SwitchControllerState& switch_state = static_cast<const SwitchControllerState&>(state);

SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController.h

@@ -91,11 +91,11 @@ class ProController : public AbstractController{
 
     //  Cancel all commands. This returns the controller to the neutral button
     //  state and clears the command queue.
-    virtual void cancel_all_commands(const Cancellable* cancellable) = 0;
+    virtual void cancel_all_commands() = 0;
 
     //  Declare that the next command will replace the current command stream
     //  with no gaps.
-    virtual void replace_on_next_command(const Cancellable* cancellable) = 0;
+    virtual void replace_on_next_command() = 0;
 
 
 public:
@@ -340,7 +340,7 @@ class ProControllerContext final : public CancellableScope{
     void cancel_now(){
         m_lifetime_sanitizer.check_usage();
         CancellableScope::cancel(nullptr);
-        m_controller.cancel_all_commands(this);
+        m_controller.cancel_all_commands();
     }
 
     //  Stop the commands in this context, but do it lazily.
@@ -354,7 +354,7 @@ class ProControllerContext final : public CancellableScope{
     void cancel_lazy(){
         m_lifetime_sanitizer.check_usage();
         CancellableScope::cancel(nullptr);
-        m_controller.replace_on_next_command(this);
+        m_controller.replace_on_next_command();
     }
 
     virtual bool cancel(std::exception_ptr exception) noexcept override{
@@ -363,7 +363,7 @@ class ProControllerContext final : public CancellableScope{
             return true;
         }
         try{
-            m_controller.cancel_all_commands(this);
+            m_controller.cancel_all_commands();
         }catch (...){}
         return false;
     }

SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController_SerialPABotBase.cpp

@@ -79,14 +79,14 @@ void ProController_SerialPABotBase::wait_for_all(const Cancellable* cancellable)
     m_serial->wait_for_all_requests(cancellable);
 //    cout << "wait_for_all() - exit" << endl;
 }
-void ProController_SerialPABotBase::cancel_all_commands(const Cancellable* cancellable){
+void ProController_SerialPABotBase::cancel_all_commands(){
     if (!is_ready()){
         throw InvalidConnectionStateException();
     }
     m_serial->stop_all_commands();
     this->clear_on_next();
 }
-void ProController_SerialPABotBase::replace_on_next_command(const Cancellable* cancellable){
+void ProController_SerialPABotBase::replace_on_next_command(){
     if (!is_ready()){
         throw InvalidConnectionStateException();
     }

SerialPrograms/Source/NintendoSwitch/Controllers/NintendoSwitch_ProController_SerialPABotBase.h

@@ -39,8 +39,8 @@ class ProController_SerialPABotBase : public ProControllerWithScheduler{
     //  General Control
 
     virtual void wait_for_all(const Cancellable* cancellable) override;
-    virtual void cancel_all_commands(const Cancellable* cancellable) override;
-    virtual void replace_on_next_command(const Cancellable* cancellable) override;
+    virtual void cancel_all_commands() override;
+    virtual void replace_on_next_command() override;
 
 
 public:

SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase_Connection.cpp

@@ -40,7 +40,9 @@ bool parse_ip_and_port(const std::string& str, QHostAddress& address, int& port)
 SysbotBaseNetwork_Connection::SysbotBaseNetwork_Connection(
     Logger& logger,
     const std::string& url
-){
+)
+    : m_logger(logger)
+{
     if (!parse_ip_and_port(url, m_address, m_port)){
         set_status(html_color_text("Invalid IP address + port.", COLOR_RED));
         return;
@@ -55,9 +57,9 @@ SysbotBaseNetwork_Connection::~SysbotBaseNetwork_Connection(){
     m_stopping.store(true, std::memory_order_release);
     {
         std::lock_guard<std::mutex> lg(m_lock);
-        if (m_socket){
-            m_socket->abort();
-        }
+//        if (m_socket){
+//            m_socket->abort();
+//        }
         m_cv.notify_all();
     }
     if (m_thread.joinable()){
@@ -78,7 +80,13 @@ std::map<ControllerType, std::set<ControllerFeature>> SysbotBaseNetwork_Connecti
 
 void SysbotBaseNetwork_Connection::write_data(const std::string& data){
     std::lock_guard<std::mutex> lg(m_lock);
+    if (m_socket == nullptr){
+        return;
+    }
+//    cout << "Sending: " << data << endl;
     qint64 written = m_socket->write(data.data(), data.size());
+    m_socket->flush();
+//    cout << "written = " << written << endl;
     if (written < 0 || written < (qint64)data.size()){
         m_ready.store(false, std::memory_order_release);
         m_stopping.store(true, std::memory_order_release);
@@ -94,21 +102,45 @@ void SysbotBaseNetwork_Connection::thread_body_wrapper(){
         std::lock_guard<std::mutex> lg(m_lock);
         m_socket = &socket;
     }
+#if 0
+    thread_body_internal();
+#else
     try{
         thread_body_internal();
-        std::lock_guard<std::mutex> lg(m_lock);
-        m_socket = nullptr;
+    }catch (Exception& e){
+        try{
+            global_logger_tagged().log("An exception was thrown from the network thread: " + e.to_str(), COLOR_RED);
+            set_status(html_color_text("Error: Unhandled Exception", COLOR_RED));
+        }catch (...){}
+    }catch (std::exception& e){
+        try{
+            global_logger_tagged().log("An exception was thrown from the network thread: " + std::string(e.what()), COLOR_RED);
+            set_status(html_color_text("Error: Unhandled Exception", COLOR_RED));
+        }catch (...){}
     }catch (...){
         try{
             global_logger_tagged().log("An exception was thrown from the network thread.", COLOR_RED);
             set_status(html_color_text("Error: Unhandled Exception", COLOR_RED));
         }catch (...){}
-        std::lock_guard<std::mutex> lg(m_lock);
-        m_socket = nullptr;
     }
+#endif
+
+    try{
+        m_socket->write("detachController\n");
+        m_socket->flush();
+        socket.close();
+    }catch (...){}
+
+    std::lock_guard<std::mutex> lg(m_lock);
+    m_socket = nullptr;
 }
 void SysbotBaseNetwork_Connection::thread_body_internal(){
-#if 0   //  REMOVE
+    std::string message =
+        "Connecting To: " + m_address.toString().toStdString() +
+        " - Port: " + std::to_string(m_port);
+
+    m_logger.log(message);
+#if 1
     m_socket->connect(
         m_socket, &QTcpSocket::disconnected,
         m_socket, [this]{
@@ -120,37 +152,52 @@ void SysbotBaseNetwork_Connection::thread_body_internal(){
     );
 #endif
 
-    m_socket->connect(
-        m_socket, &QTcpSocket::disconnected,
-        m_socket, [this]{
-            m_stopping.store(true, std::memory_order_release);
-        }
-    );
-
     m_socket->connectToHost(m_address, m_port);
 
     WallClock start = current_time();
     WallClock deadline = start + std::chrono::seconds(30);
     while (true){
         if (current_time() > deadline){
+            m_logger.log("Connection timed out.", COLOR_RED);
             set_status(html_color_text("Connection timed out.", COLOR_RED));
             return;
         }
         if (m_stopping.load(std::memory_order_acquire)){
+            m_logger.log("Connection aborted.", COLOR_RED);
             return;
         }
         if (m_socket->waitForConnected(50)){
             break;
         }
     }
 
+    m_logger.log(message + " (Success)", COLOR_BLUE);
     set_status(html_color_text("Connected!", COLOR_BLUE));
 
     declare_ready(supported_controllers());
 
-//    m_socket->write("press X\r\n");
-
-
+    m_socket->write("configure mainLoopSleepTime 0\n");
+    m_socket->flush();
+
+    //
+    //  This is stupid. Since we cannot block the constructor of this class to
+    //  wait for the connection, we spawn this thread to do the connection.
+    //  This thread is no longer needed once we've connected and have reported
+    //  the status.
+    //
+    //  However, QTcpSocket doesn't like being constructed on one thread
+    //  and connecting out from another. So we construct it in this thread.
+    //  It also means we cannot destruct it until we're done using it. Thus we
+    //  must keep this thread alive until the entire class dies.
+    //
+    //  If we ever need to receive packets from this connection, this would be
+    //  the thread to do it on.
+    //
+
+    std::unique_lock<std::mutex> lg(m_lock);
+    m_cv.wait(lg, [this]{
+        return m_stopping.load(std::memory_order_relaxed);
+    });
 }
 
 

SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase_Connection.h

@@ -36,6 +36,7 @@ class SysbotBaseNetwork_Connection : public ControllerConnection{
     void thread_body_internal();
 
 private:
+    Logger& m_logger;
     QHostAddress m_address;
     int m_port;
 

SerialPrograms/Source/NintendoSwitch/Controllers/SysbotBase/SysbotBase_Descriptor.cpp

@@ -10,6 +10,10 @@
 #include "SysbotBase_ProController.h"
 #include "SysbotBase_SelectorWidget.h"
 
+//#include <iostream>
+//using std::cout;
+//using std::endl;
+
 namespace PokemonAutomation{
 
 template class InterfaceType_t<SysbotBase::SysbotBaseNetwork_Descriptor>;