let the zmq client shut down on purpose

biotracker/src/ZmqTrackingAlgorithm.cpp

@@ -8,11 +8,6 @@ namespace BioTracker {
 namespace Core {
 namespace Zmq {
 
-
-inline void setSenderId(QWidget *w, const QString id) {
-    w->setAccessibleName(id);
-}
-
 /**
  * @brief ZmqTrackingAlgorithm::ZmqTrackingAlgorithm
  * @param process
@@ -57,9 +52,10 @@ void ZmqTrackingAlgorithm::paintOverlay(QPainter *p, const View &v) {
 }
 
 std::shared_ptr<QWidget> ZmqTrackingAlgorithm::getToolsWidget() {
-    SendRequestWidgetsMessage message(m_tools);
+    std::shared_ptr<QWidget> tools(new QWidget);
+    SendRequestWidgetsMessage message(tools);
     m_process->send(message, m_events);
-    return m_tools;
+    return tools;
 }
 
 void ZmqTrackingAlgorithm::prepareSave() {

biotracker/src/zmq/ZmqClientProcess.cpp

@@ -4,6 +4,8 @@
 #include <QProcess>
 #include <QString>
 
+#include <thread>
+#include <chrono>
 #include "biotracker/zmq/ZmqHelper.h"
 
 namespace BioTracker {
@@ -18,8 +20,9 @@ void *SOCKET; // TODO make this a member variable. To do so, we need to provide
 // PUBLIC
 // =========================================
 
-ZmqClientProcess::ZmqClientProcess(ZmqInfoFile info, void *socket, std::string url, const int ts) {
-    if (isFree) { // there can be only ONE ZmqClientProcess at the same time!
+ZmqClientProcess::ZmqClientProcess(ZmqInfoFile info, void *socket, std::string url, const int ts):
+    m_isAlive(true) {
+    if (isFree) { // ATM there can be only ONE ZmqClientProcess at the same time!
         SOCKET = socket;
         isFree = false;
     } else {
@@ -53,55 +56,60 @@ ZmqClientProcess::ZmqClientProcess(ZmqInfoFile info, void *socket, std::string u
 
 void ZmqClientProcess::send(GenericSendMessage &message, EventHandler &handler) {
     m_zmqMutex.lock();
-    switch (message.type) {
-    case None: {
-        throw std::invalid_argument("Message type must not be 'None'");
-        break;
-    }
-    case Track: {
-        auto &m = static_cast<SendTrackMessage &>(message);
-        track(m, handler);
-        break;
-    }
-    case Paint: {
-        auto &m = static_cast<SendPaintMessage &>(message);
-        paint(m, handler);
-        break;
-    }
-    case PaintOverlay: {
-        auto &m = static_cast<SendPaintOverlayMessage &>(message);
-        paintOverlay(m, handler);
-        break;
-    }
-    case RequestTools: {
-        auto &m = static_cast<SendRequestWidgetsMessage &>(message);
-        requestTools(m, handler);
-        break;
-    }
-    case ButtonClick: {
-        auto &m = static_cast<SendButtonClickMessage &>(message);
-        buttonClicked(m, handler);
-        break;
-    }
-    case ValueChanged: {
-        auto &m = static_cast<SendValueChangedMessage &>(message);
-        sendValue(m, handler);
-        break;
-    }
+    if (m_isAlive) {
+        switch (message.type) {
+        case None: {
+            throw std::invalid_argument("Message type must not be 'None'");
+            break;
+        }
+        case Track: {
+            auto &m = static_cast<SendTrackMessage &>(message);
+            track(m, handler);
+            break;
+        }
+        case Paint: {
+            auto &m = static_cast<SendPaintMessage &>(message);
+            paint(m, handler);
+            break;
+        }
+        case PaintOverlay: {
+            auto &m = static_cast<SendPaintOverlayMessage &>(message);
+            paintOverlay(m, handler);
+            break;
+        }
+        case RequestTools: {
+            auto &m = static_cast<SendRequestWidgetsMessage &>(message);
+            requestTools(m, handler);
+            break;
+        }
+        case ButtonClick: {
+            auto &m = static_cast<SendButtonClickMessage &>(message);
+            buttonClicked(m, handler);
+            break;
+        }
+        case ValueChanged: {
+            auto &m = static_cast<SendValueChangedMessage &>(message);
+            sendValue(m, handler);
+            break;
+        }
+        }
     }
     m_zmqMutex.unlock();
 }
 
 void ZmqClientProcess::shutdown() {
     isFree = true;
+    m_isAlive = false;
     m_zmqMutex.lock();
     send_string(SOCKET, TYPE_SHUTDOWN, 0);
     EventHandler temp(this);
     listenToEvents(temp);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
     m_zmqClient->kill();
     m_zmqClient->waitForFinished(1000);
     zmq_disconnect(SOCKET, "172.0.0.1:5556");
     zmq_close(SOCKET);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
     m_zmqMutex.unlock();
 }
 

biotracker/src/zmq/ZmqMessageParser.cpp

@@ -121,7 +121,7 @@ const QString EVENT_MSG_FALSE("0");
 
 void EventHandler::receive(BioTracker::Core::Zmq::recvString receiveStr) {
     auto string = receiveStr();
-    while (string != EVENT_STOP_LISTENING) {
+    while (string != EVENT_STOP_LISTENING && string != FAILED_RECV_STRING) {
         if (string == EVENT_UPDATE) {
             Q_EMIT update();
         } else if (string == EVENT_FORCE_TRACKING) {
@@ -150,6 +150,7 @@ void EventHandler::receive(BioTracker::Core::Zmq::recvString receiveStr) {
                     Q_EMIT pausePlayback(true);
                 }
             } else {
+                std::cout << "WRONG EVENT:" << string.toStdString() << std::endl;
                 assert(false);
             }
         }

biotracker/src/zmq/ZmqProcessHandler.cpp

@@ -11,6 +11,7 @@ namespace Zmq {
  */
 ZmqProcessHandler::ZmqProcessHandler():
     m_context(zmq_ctx_new()) {
+    std::cout << "start handler2" << std::endl;
 
 }
 
@@ -19,6 +20,10 @@ ZmqProcessHandler::ZmqProcessHandler():
  * @brief ZmqProcessHandler::~ZmqProcessHandler
  */
 ZmqProcessHandler::~ZmqProcessHandler() {
+    if (m_currentProcess) {
+        m_currentProcess->shutdown();
+        m_currentProcess.reset();
+    }
     zmq_ctx_term(m_context);
 }
 
@@ -29,7 +34,7 @@ std::shared_ptr<ZmqClientProcess> ZmqProcessHandler::startProcess(ZmqInfoFile &i
     }
 
     void *socket = zmq_socket(m_context, ZMQ_PAIR);
-    m_currentProcess = std::make_shared<ZmqClientProcess>(info, std::move(socket));
+    m_currentProcess = std::make_shared<ZmqClientProcess>(info, socket);
 
     return m_currentProcess;
 }

biotracker/zmq/ZmqClientProcess.h

@@ -57,6 +57,7 @@ class ZmqClientProcess: public QObject {
 
     std::unique_ptr<QProcess> m_zmqClient;
     std::mutex m_zmqMutex;
+    bool m_isAlive;
 
 };
 

biotracker/zmq/ZmqHelper.h

@@ -20,6 +20,7 @@ namespace BioTracker {
 namespace Core {
 namespace Zmq {
 
+
 /**
  * @brief recv_string
  *    receives a string from the given socket
@@ -31,7 +32,10 @@ inline QString recv_string(void *socket) {
     int rc = zmq_msg_init(&msg);
     assert(rc == 0);
     const int bytes = zmq_msg_recv(&msg, socket, 0);
-    auto string = QString::fromLocal8Bit(static_cast<char *>(zmq_msg_data(&msg)), bytes);
+    auto string = FAILED_RECV_STRING;
+    if (bytes > 0) {
+        string = QString::fromLocal8Bit(static_cast<char *>(zmq_msg_data(&msg)), bytes);
+    }
     zmq_msg_close(&msg);
     return string;
 }

biotracker/zmq/ZmqMessageParser.h

@@ -28,6 +28,8 @@ const QString TYPE_SEND_WIDGET_EVENT("5");
 const QString WIDGET_EVENT_CLICK("0");
 const QString WIDGET_EVENT_CHANGED("1");
 
+const QString FAILED_RECV_STRING("FAILEDRECVSTR");
+
 
 const cv::Mat DEFAULT_1x1(1,1, CV_8UC3);