Merge pull request #642 from deXol/developAddLocalSocketForEmulator

Add emulator support

Author: limpkin

daemon.pro

@@ -57,6 +57,7 @@ mac {
 
 SOURCES += src/main_daemon.cpp \
     src/MPDevice.cpp \
+    src/MPDevice_localSocket.cpp \
     src/MPManager.cpp \
     src/Common.cpp \
     src/WSServer.cpp \
@@ -88,6 +89,7 @@ SOURCES += src/main_daemon.cpp \
 HEADERS  += \
     src/Common.h \
     src/MPDevice.h \
+    src/MPDevice_localSocket.h \
     src/MPManager.h \
     src/MooltipassCmds.h \
     src/QtHelper.h \

src/MPDevice.cpp

@@ -3528,7 +3528,7 @@ void MPDevice::processStatusChange(const QByteArray &data)
     Common::MPStatus s = pMesProt->getStatus(data);
     Common::MPStatus prevStatus = get_status();
 
-    if (isBLE())
+    if (isBLE() && Common::Unlocked == s)
     {
         bleImpl->readUserSettings(pMesProt->getPayloadBytes(data, 2, 4));
     }

src/MPDevice_localSocket.cpp

@@ -0,0 +1,141 @@
+/******************************************************************************
+ **  Copyright (c) Andrzej Szombierski. All Rights Reserved.
+ **
+ **  Moolticute is free software; you can redistribute it and/or modify
+ **  it under the terms of the GNU General Public License as published by
+ **  the Free Software Foundation; either version 3 of the License, or
+ **  (at your option) any later version.
+ **
+ **  Moolticute 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.
+ **
+ **  You should have received a copy of the GNU General Public License
+ **  along with Moolticute; if not, write to the Free Software
+ **  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ **
+ ******************************************************************************/
+#include "MPDevice_localSocket.h"
+#include <QDebug>
+
+MPDeviceLocalMonitor::MPDeviceLocalMonitor()
+{
+    const char *socketName = "moolticuted_local_dev";
+    QLocalServer::removeServer(socketName);
+    server.listen(socketName);
+    connect(&server, SIGNAL(newConnection()), this, SLOT(acceptIncomingConnection()));
+}
+
+void MPDeviceLocalMonitor::acceptIncomingConnection()
+{
+    while(server.hasPendingConnections()) {
+        auto newSocket = server.nextPendingConnection();
+        if(!newSocket)
+            continue;
+
+        QString id = QString::number(++nextId);
+        connect(newSocket, SIGNAL(disconnected()), this, SLOT(connectionLost()));
+        sockets[id] = newSocket;
+        emulatorRunning = true;
+        emit localDeviceAdded(id);
+    }
+}
+
+void MPDeviceLocalMonitor::connectionLost()
+{
+    auto socket = static_cast<QLocalSocket*>(sender());
+    emulatorRunning = false;
+
+    // this is not the greatest way to search for the socket, but realistically this map will only have one entry
+    for(auto it = sockets.begin(); it != sockets.end(); ++it) {
+        if(it.value() == socket) {
+            QString id = it.key();
+            sockets.erase(it);
+            emit localDeviceRemoved(id);
+            break;
+        }
+    }
+
+    socket->deleteLater();
+}
+
+QList<MPLocalDef> MPDeviceLocalMonitor::enumerateDevices() const
+{
+    QList<MPLocalDef> ret;
+    for(auto it = sockets.begin(); it != sockets.end(); ++it)
+        ret.append(MPLocalDef { it.key() });
+    return ret;
+}
+
+
+MPDevice_localSocket::MPDevice_localSocket(QObject *parent, const MPLocalDef & def): MPDevice(parent)
+{
+    socket = MonitorInstance()->sockets[def.id];
+    deviceType = DeviceType::BLE;
+    isBluetooth = false;
+
+    if(socket)
+        connect(socket, SIGNAL(readyRead()), this, SLOT(readData()));
+
+    setupMessageProtocol();
+#ifndef Q_OS_UNIX
+    sendInitMessages();
+#endif
+}
+
+MPDevice_localSocket::~MPDevice_localSocket()
+{
+}
+
+void MPDevice_localSocket::readData()
+{
+    // QLocalSocket is stream-based, meaning that it can arbitrarily merge/split data packets
+    // We will split the HID packets based on the payload length field
+    if(!socket)
+        return;
+
+    for(;;) {
+        if(incomingPacketFill >= 2) {
+            int payloadLength = incomingPacket[0] & 63;
+            if(payloadLength > 62) {
+                qWarning() << "Invalid HID packet received";
+                incomingPacketFill = 0;
+                continue;
+            }
+
+            if(incomingPacketFill >= 2 + payloadLength) {
+                // return one packet
+                emit platformDataRead(QByteArray((const char*)incomingPacket, 2 + payloadLength));
+
+                // shift bytes in buffer
+                incomingPacketFill -= 2 + payloadLength;
+                memmove(incomingPacket, incomingPacket + 2 + payloadLength, incomingPacketFill);
+                continue;
+            }
+        }
+
+        int bytesRead = socket->read((char*)incomingPacket + incomingPacketFill, sizeof(incomingPacket) - incomingPacketFill);
+
+        if(bytesRead < 0) {
+            incomingPacketFill = 0;
+            return; // socket closed?
+        }
+
+        if(bytesRead == 0)
+            break;
+
+        incomingPacketFill += bytesRead;
+    }
+}
+
+void MPDevice_localSocket::platformWrite(const QByteArray &ba)
+{
+    if(socket)
+        socket->write(ba);
+}
+
+void MPDevice_localSocket::platformRead()
+{
+    // nothing to do
+}

src/MPDevice_localSocket.h

@@ -0,0 +1,87 @@
+/******************************************************************************
+ **  Copyright (c) Andrzej Szombierski. All Rights Reserved.
+ **
+ **  Moolticute is free software; you can redistribute it and/or modify
+ **  it under the terms of the GNU General Public License as published by
+ **  the Free Software Foundation; either version 3 of the License, or
+ **  (at your option) any later version.
+ **
+ **  Moolticute 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.
+ **
+ **  You should have received a copy of the GNU General Public License
+ **  along with Moolticute; if not, write to the Free Software
+ **  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ **
+ ******************************************************************************/
+#ifndef MPDEVICE_LOCALSOCKET_H
+#define MPDEVICE_LOCALSOCKET_H
+
+#include "MPDevice.h"
+#include <QLocalServer>
+#include <QLocalSocket>
+
+struct MPLocalDef {
+    QString id;
+};
+
+class MPDeviceLocalMonitor: public QObject {
+    Q_OBJECT
+    friend class MPDevice_localSocket;
+
+public:
+    MPDeviceLocalMonitor();
+    QList<MPLocalDef> enumerateDevices() const;
+
+signals:
+    void localDeviceAdded(QString id);
+    void localDeviceRemoved(QString id);
+
+private slots:
+    void acceptIncomingConnection();
+    void connectionLost();
+
+private:
+    QLocalServer server;
+    QMap<QString, QLocalSocket *> sockets;
+
+    int nextId = 0;
+    bool emulatorRunning = false;
+};
+
+class MPDevice_localSocket: public MPDevice
+{
+    Q_OBJECT
+
+public:
+    MPDevice_localSocket(QObject *parent, const MPLocalDef & def);
+    virtual ~MPDevice_localSocket();
+
+    static MPDeviceLocalMonitor *MonitorInstance() {
+        static MPDeviceLocalMonitor inst;
+        return &inst;
+    }
+
+    static QList<MPLocalDef> enumerateDevices() {
+        return MonitorInstance()->enumerateDevices();
+    }
+
+    bool isEmulatorRunning() const { return MonitorInstance()->emulatorRunning; }
+
+private slots:
+    void readData();
+
+private:
+    virtual void platformRead();
+    virtual void platformWrite(const QByteArray &data);
+
+    QPointer<QLocalSocket> socket;
+
+    // incoming messages
+    uint8_t incomingPacket[64];
+    int incomingPacketFill = 0;
+};
+
+#endif // MPDEVICE_LOCALSOCKET_H

src/MPManager.cpp

@@ -26,6 +26,7 @@
 #elif defined(Q_OS_MAC)
 #include "UsbMonitor_mac.h"
 #endif
+#include "MPDevice_localSocket.h"
 
 MPManager::MPManager():
     QObject(nullptr)
@@ -52,6 +53,10 @@ bool MPManager::initialize()
 #endif
     }
 
+    // no localSocket devices will ever be connected at startup
+    connect(MPDevice_localSocket::MonitorInstance(), SIGNAL(localDeviceAdded(QString)), this, SLOT(usbDeviceAdded()));
+    connect(MPDevice_localSocket::MonitorInstance(), SIGNAL(localDeviceRemoved(QString)), this, SLOT(usbDeviceRemoved(QString)));
+
     bool startUsbCheck = true;
 #if defined(Q_OS_MAC)
     //This is not needed on osx, the list is updated at startup by UsbMonitor
@@ -101,6 +106,9 @@ void MPManager::usbDeviceAdded(QString path)
     Q_UNUSED(path);
     return;
 #endif
+
+    disconnectLocalSocketDevice();
+
     if (devices.empty())
     {
         MPDevice *device = nullptr;
@@ -136,6 +144,8 @@ void MPManager::usbDeviceAdded(QString path)
 #if defined(Q_OS_LINUX)
 void MPManager::usbDeviceAdded(QString path, bool isBLE, bool isBT)
 {
+    disconnectLocalSocketDevice();
+
     if (devices.empty())
     {
         if (isBLE && isBLEConnectedWithUsb())
@@ -217,16 +227,17 @@ void MPManager::checkUsbDevices()
 
     if (devlist.isEmpty() && !AppDaemon::isEmulationMode())
     {
-        //No USB devices found, means all MPs are gone disconnected
-        qDebug() << "Disconnecting devices";
-        auto it = devices.begin();
-        while (it != devices.end())
+        if (isLocalSocketDeviceConnected()
+        #ifndef Q_OS_UNIX
+                || !devices.isEmpty()
+        #endif
+           )
         {
-            emit mpDisconnected(it.value());
-            delete it.value();
-            it++;
+            return;
         }
-        devices.clear();
+        //No USB devices found, means all MPs are gone disconnected
+        disconnectingDevices();
+        checkLocalSocketDevice();
         return;
     }
 
@@ -295,9 +306,67 @@ void MPManager::checkUsbDevices()
     }
 }
 
+void MPManager::checkLocalSocketDevice()
+{
+    QList<MPLocalDef> local_devlist = MPDevice_localSocket::enumerateDevices();
+    for (const MPLocalDef &def : local_devlist)
+    {
+        //This is a new connected mooltipass
+        if (!devices.contains(def.id))
+        {
+            MPDevice *device = new MPDevice_localSocket(this, def);
+
+            devices[def.id] = device;
+            emit mpConnected(device);
+        }
+        else
+        {
+            qDebug() << "Device is already connected: " << def.id;
+        }
+    }
+}
+
+bool MPManager::isLocalSocketDeviceConnected()
+{
+    auto it = std::find_if(devices.begin(), devices.end(),
+         [](MPDevice *dev)
+        {
+            auto* localDev = dynamic_cast<MPDevice_localSocket*>(dev);
+            if (localDev && localDev->isEmulatorRunning())
+            {
+                return true;
+            }
+            return false;
+        });
+    return it != devices.end();
+}
+
+void MPManager::disconnectLocalSocketDevice()
+{
+    if (isLocalSocketDeviceConnected())
+    {
+        qDebug() << "Device is connected, emulator disconnecting";
+        emit sendNotification("show_emulator_disconnect");
+        disconnectingDevices();
+    }
+}
+
 bool MPManager::isBLEConnectedWithUsb()
 {
     return std::find_if(devices.begin(), devices.end(),
               [](MPDevice * dev){ return dev->isBLE();})
-            != devices.end();
+    != devices.end();
+}
+
+void MPManager::disconnectingDevices()
+{
+    qDebug() << "Disconnecting devices";
+    auto it = devices.begin();
+    while (it != devices.end())
+    {
+        emit mpDisconnected(it.value());
+        delete it.value();
+        it++;
+    }
+    devices.clear();
 }