feat(simulator): add local socket backend for aux serial ports

Adds QLocalSocketBackend so user scripts can stand in for hardware
on simulator aux serial ports. Backed by QLocalServer, which uses
AF_UNIX on macOS / Linux and named pipes on Windows — no #ifdefs
on our side. Single-client semantics: a second connection while
one is active is rejected.

The Configure Serial Ports dialog grows a per-port type selector
(Not assigned / Serial port / Local socket) with a context-
dependent input widget — combo for serial, line edit prefilled
with edgetx-sim-aux<N> for sockets. While a socket is listening
the dialog shows the resolved native path so users know where
to point their script.

HostSerialConnector::connectSerialPort is replaced with a
generic connectBackend(index, kind, spec). Per-port encoding /
baudrate are still cached on the connector and re-applied across
backend swaps; setEncoding/setBaudrate are no-ops on the socket
backend.

Qt Network is now an explicit find_package COMPONENTS entry and
linked into the common library. It was previously pulled in
transitively by QNetworkAccessManager in updates/.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: raphaelcoeffic

cmake/QtDefs.cmake

@@ -13,7 +13,7 @@ if(Qt6_FOUND)
   # call after Qt6Core package is found
   qt_standard_project_setup()
 
-  find_package(Qt6 REQUIRED COMPONENTS Widgets LinguistTools Multimedia PrintSupport SerialPort Svg Xml)
+  find_package(Qt6 REQUIRED COMPONENTS Widgets LinguistTools Multimedia Network PrintSupport SerialPort Svg Xml)
 
   ### Get locations of Qt binary executables & libs (libs are for distros, not for linking)
   # first set up some hints

companion/src/CMakeLists.txt

@@ -189,6 +189,7 @@ target_link_libraries(common
   Qt::Xml
   Qt::Widgets
   Qt::SerialPort
+  Qt::Network
   ${SDL2_LIBRARIES}
 )
 

companion/src/simulation/CMakeLists.txt

@@ -21,6 +21,7 @@ set(${PROJECT_NAME}_NAMES
   widgets/virtualjoystickwidget
   serialportsdialog
   hostserialbackend_serialport
+  hostserialbackend_localsocket
   hostserialconnector
   simulateduiwidgetGeneric
   wasmsimulatorinterface

companion/src/simulation/hostserialbackend_localsocket.cpp

@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) EdgeTX
+ *
+ * Based on code named
+ *   opentx - https://github.com/opentx/opentx
+ *   th9x - http://code.google.com/p/th9x
+ *   er9x - http://code.google.com/p/er9x
+ *   gruvin9x - http://code.google.com/p/gruvin9x
+ *
+ * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "hostserialbackend_localsocket.h"
+
+#include <QLocalServer>
+#include <QLocalSocket>
+#include <QtDebug>
+
+QLocalSocketBackend::QLocalSocketBackend(const QString & socketName, QObject * parent)
+  : HostSerialBackend(parent),
+    socketName(socketName),
+    server(new QLocalServer(this)),
+    client(nullptr)
+{
+  connect(server, &QLocalServer::newConnection,
+          this, &QLocalSocketBackend::onNewConnection);
+}
+
+QLocalSocketBackend::~QLocalSocketBackend()
+{
+  close();
+}
+
+bool QLocalSocketBackend::open()
+{
+  if (server->isListening())
+    return true;
+
+  // A previous run (or another process) may have left a stale socket
+  // file behind on Unix; QLocalServer::removeServer is the documented
+  // way to clear it before re-listening.
+  QLocalServer::removeServer(socketName);
+
+  if (!server->listen(socketName)) {
+    emit errorOccurred(tr("Failed to listen on local socket \"%1\": %2")
+                       .arg(socketName, server->errorString()));
+    return false;
+  }
+
+  qDebug() << "Listening on local socket" << server->fullServerName();
+  return true;
+}
+
+void QLocalSocketBackend::close()
+{
+  if (client != nullptr) {
+    client->disconnect(this);
+    client->disconnectFromServer();
+    client->deleteLater();
+    client = nullptr;
+  }
+  if (server->isListening())
+    server->close();
+}
+
+bool QLocalSocketBackend::isOpen() const
+{
+  return server->isListening();
+}
+
+void QLocalSocketBackend::write(const QByteArray & data)
+{
+  if (client != nullptr && client->state() == QLocalSocket::ConnectedState)
+    client->write(data);
+}
+
+QString QLocalSocketBackend::displayName() const
+{
+  return socketName;
+}
+
+QString QLocalSocketBackend::fullServerName() const
+{
+  return server->isListening() ? server->fullServerName() : QString();
+}
+
+void QLocalSocketBackend::onNewConnection()
+{
+  while (server->hasPendingConnections()) {
+    QLocalSocket * incoming = server->nextPendingConnection();
+    if (client != nullptr) {
+      // Single-client backend: politely refuse extra connections.
+      incoming->disconnectFromServer();
+      incoming->deleteLater();
+      continue;
+    }
+
+    client = incoming;
+    connect(client, &QLocalSocket::readyRead,
+            this, &QLocalSocketBackend::onClientReadyRead);
+    connect(client, &QLocalSocket::disconnected,
+            this, &QLocalSocketBackend::onClientDisconnected);
+    qDebug() << "Local socket client connected on" << socketName;
+  }
+}
+
+void QLocalSocketBackend::onClientReadyRead()
+{
+  if (client == nullptr)
+    return;
+  emit dataReceived(client->readAll());
+}
+
+void QLocalSocketBackend::onClientDisconnected()
+{
+  if (client == nullptr)
+    return;
+  client->deleteLater();
+  client = nullptr;
+  qDebug() << "Local socket client disconnected from" << socketName;
+}

companion/src/simulation/hostserialbackend_localsocket.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) EdgeTX
+ *
+ * Based on code named
+ *   opentx - https://github.com/opentx/opentx
+ *   th9x - http://code.google.com/p/th9x
+ *   er9x - http://code.google.com/p/er9x
+ *   gruvin9x - http://code.google.com/p/gruvin9x
+ *
+ * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#pragma once
+
+#include "hostserialbackend.h"
+
+class QLocalServer;
+class QLocalSocket;
+
+// HostSerialBackend backed by a QLocalServer (Unix domain socket on
+// macOS / Linux, named pipe on Windows). Lets external scripts stand
+// in for hardware on a simulator aux serial port.
+//
+// Single-client semantics: while one client is connected, additional
+// connection attempts are accepted briefly and then closed. We use
+// last-write-wins for outgoing data — bytes from the simulator only
+// reach the active client.
+class QLocalSocketBackend : public HostSerialBackend
+{
+    Q_OBJECT
+
+  public:
+    QLocalSocketBackend(const QString & socketName, QObject * parent = nullptr);
+    ~QLocalSocketBackend() override;
+
+    bool open() override;
+    void close() override;
+    bool isOpen() const override;
+
+    void write(const QByteArray & data) override;
+
+    QString displayName() const override;
+
+    // Resolved native path / pipe name (e.g.
+    // /var/folders/.../edgetx-sim-aux1 or
+    // \\.\pipe\edgetx-sim-aux1). Empty when the server is not
+    // listening.
+    QString fullServerName() const;
+
+  private slots:
+    void onNewConnection();
+    void onClientReadyRead();
+    void onClientDisconnected();
+
+  private:
+    QString socketName;
+    QLocalServer * server;
+    QLocalSocket * client;
+};

companion/src/simulation/hostserialconnector.cpp

@@ -23,13 +23,15 @@
 
 #include "hostserialbackend.h"
 #include "hostserialbackend_serialport.h"
+#include "hostserialbackend_localsocket.h"
 
 HostSerialConnector::HostSerialConnector(QObject *parent, SimulatorInterface *simulator)
   : QObject(parent),
     simulator(simulator)
 {
   for (int i = 0; i < MAX_HOST_SERIAL; i++) {
     hostAuxBackends[i] = nullptr;
+    hostAuxBackendKinds[i] = BackendNone;
     hostAuxPortsEncoding[i] = SERIAL_ENCODING_8N1;
     hostAuxPortsBaudRate[i] = 9600;
     hostAuxPortsOpen[i] = false;
@@ -46,21 +48,44 @@ HostSerialConnector::~HostSerialConnector()
   }
 }
 
-QString HostSerialConnector::getConnectedSerialPortName(int index)
+HostSerialConnector::BackendKind HostSerialConnector::getBackendKind(int index) const
 {
   if (index >= MAX_HOST_SERIAL)
-    return QString("");
+    return BackendNone;
+
+  QMutexLocker locker(&hostAuxPortsMutex);
+  return hostAuxBackendKinds[index];
+}
+
+QString HostSerialConnector::getBackendSpec(int index) const
+{
+  if (index >= MAX_HOST_SERIAL)
+    return QString();
 
   QMutexLocker locker(&hostAuxPortsMutex);
 
   HostSerialBackend * backend = hostAuxBackends[index];
   if (backend == nullptr)
-    return QString("");
+    return QString();
 
   return backend->displayName();
 }
 
-void HostSerialConnector::setBackend(int index, HostSerialBackend * backend)
+QString HostSerialConnector::getLocalSocketFullName(int index) const
+{
+  if (index >= MAX_HOST_SERIAL)
+    return QString();
+
+  QMutexLocker locker(&hostAuxPortsMutex);
+
+  if (hostAuxBackendKinds[index] != BackendLocalSocket)
+    return QString();
+
+  auto * backend = qobject_cast<QLocalSocketBackend *>(hostAuxBackends[index]);
+  return backend != nullptr ? backend->fullServerName() : QString();
+}
+
+void HostSerialConnector::setBackend(int index, HostSerialBackend * backend, BackendKind kind)
 {
   // Caller holds hostAuxPortsMutex.
   HostSerialBackend * old = hostAuxBackends[index];
@@ -70,6 +95,7 @@ void HostSerialConnector::setBackend(int index, HostSerialBackend * backend)
   }
 
   hostAuxBackends[index] = backend;
+  hostAuxBackendKinds[index] = backend != nullptr ? kind : BackendNone;
 
   if (backend == nullptr)
     return;
@@ -88,19 +114,31 @@ void HostSerialConnector::setBackend(int index, HostSerialBackend * backend)
   backend->setBaudrate(hostAuxPortsBaudRate[index]);
 }
 
-void HostSerialConnector::connectSerialPort(int index, QString portName)
+void HostSerialConnector::connectBackend(int index, int kind, const QString & spec)
 {
   if (index >= MAX_HOST_SERIAL)
     return;
 
   QMutexLocker locker(&hostAuxPortsMutex);
 
-  if (portName.isEmpty()) {
-    setBackend(index, nullptr);
+  if (kind == BackendNone || spec.isEmpty()) {
+    setBackend(index, nullptr, BackendNone);
     return;
   }
 
-  setBackend(index, new QSerialPortBackend(portName, this));
+  HostSerialBackend * backend = nullptr;
+  switch (kind) {
+    case BackendSerialPort:
+      backend = new QSerialPortBackend(spec, this);
+      break;
+    case BackendLocalSocket:
+      backend = new QLocalSocketBackend(spec, this);
+      break;
+    default:
+      return;
+  }
+
+  setBackend(index, backend, static_cast<BackendKind>(kind));
 
   if (hostAuxPortsOpen[index])
     serialStart(index);

companion/src/simulation/hostserialconnector.h

@@ -39,13 +39,28 @@ class HostSerialConnector : public QObject
     Q_OBJECT
 
   public:
+    enum BackendKind {
+      BackendNone = 0,
+      BackendSerialPort,
+      BackendLocalSocket,
+    };
+    Q_ENUM(BackendKind)
+
     explicit HostSerialConnector(QObject * parent, SimulatorInterface * simulator);
     ~HostSerialConnector();
 
-    QString getConnectedSerialPortName(int index);
+    BackendKind getBackendKind(int index) const;
+    QString getBackendSpec(int index) const;
+
+    // Convenience: only meaningful when the active backend is a
+    // QLocalSocketBackend. Returns an empty string otherwise.
+    QString getLocalSocketFullName(int index) const;
 
   public slots:
-    void connectSerialPort(int index, QString portName);
+    // kind=BackendNone or empty spec disconnects the port. For
+    // BackendSerialPort, spec is the device name (e.g. "ttyUSB0");
+    // for BackendLocalSocket, spec is the QLocalServer listen name.
+    void connectBackend(int index, int kind, const QString & spec);
     void sendSerialData(const quint8 index, const QByteArray & data);
     void setSerialEncoding(const quint8 index, const quint8 encoding);
     void setSerialBaudRate(const quint8 index, const quint32 baudrate);
@@ -58,12 +73,13 @@ class HostSerialConnector : public QObject
     void backendError(int index, const QString & message);
 
   private:
-    void setBackend(int index, HostSerialBackend * backend);
+    void setBackend(int index, HostSerialBackend * backend, BackendKind kind);
 
     SimulatorInterface * simulator;
 
-    QRecursiveMutex hostAuxPortsMutex;
+    mutable QRecursiveMutex hostAuxPortsMutex;
     HostSerialBackend * hostAuxBackends[MAX_HOST_SERIAL];
+    BackendKind hostAuxBackendKinds[MAX_HOST_SERIAL];
     quint8 hostAuxPortsEncoding[MAX_HOST_SERIAL];
     quint32 hostAuxPortsBaudRate[MAX_HOST_SERIAL];
     bool hostAuxPortsOpen[MAX_HOST_SERIAL];