Initial start on Recorder

recorder/include/recorder.h

@@ -1,6 +1,19 @@
 #ifndef GERMANAIRLINESVA_GACONNECTOR_RECORDER_RECORDER_H
 #define GERMANAIRLINESVA_GACONNECTOR_RECORDER_RECORDER_H
 
+#include <atomic>
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <thread>
+
+#include "websocket.h"
+
+#include "config/config.hpp"
+#include "logbook/logbook.hpp"
+#include "recording/recording.hpp"
+#include "simdata/simDatabase.hpp"
+
 namespace germanairlinesva
 {
 namespace gaconnector
@@ -9,6 +22,38 @@ namespace gaconnector
   {
     class Recorder
     {
+      private:
+        std::function<void(const std::string)> toLog;
+
+        std::mutex mutex;
+        std::thread serverThread;
+        std::thread recordingThread;
+        std::atomic<bool> wantsExit{false};
+
+        std::shared_ptr<file::config::Config> configuration;
+        std::unique_ptr<file::simdata::SimDatabase> database;
+        std::unique_ptr<websocket::Websocket> connector;
+
+        websocket::data toSend;
+
+        std::queue<std::function<void()>> &messageQueue()
+        {
+          static std::queue<std::function<void()>> _messageQueue;
+          return _messageQueue;
+        }
+
+        void serverWorker();
+        void recordingWorker();
+
+        // For Testing
+        void test() const;
+
+      public:
+        Recorder(int simVersion, std::function<void(const std::string)> toLog);
+        ~Recorder();
+
+        void setData(websocket::data &data);
+        void handleMessages();
     };
   } // namespace recorder
 } // namespace gaconnector

recorder/recorder.cpp

@@ -0,0 +1,180 @@
+#include "include/recorder.h"
+
+namespace germanairlinesva
+{
+namespace gaconnector
+{
+  namespace recorder
+  {
+    Recorder::Recorder(int simVersion,
+                       std::function<void(const std::string)> toLog)
+        : toLog(std::move(toLog))
+    {
+      // Configuration
+      this->configuration = std::make_shared<file::config::Config>();
+      this->toLog("Configuration loaded");
+
+// Database
+#ifdef XP
+      char hash[2 * MD5LEN + 1] = "";
+      if (utilities::generateMD5(XPLANE_CUSTOM_SCENERY, hash, toLog) == 0) {
+        this->database =
+            std::make_unique<file::simdata::SimDatabase>(simVersion,
+                                                         hash,
+                                                         this->configuration,
+                                                         this->toLog);
+      }
+#endif
+#ifndef MSFS
+#endif
+
+      // WebSocket
+      this->connector = std::make_unique<websocket::Websocket>(
+          "wss://ws.hofmannnet.myhome-server.de:8000",
+          this->configuration->getUser(),
+          this->toLog);
+      this->toLog("WebSocket started");
+
+      // For Testing
+      this->test();
+
+      // Thread for sending data to websocket
+      this->serverThread = std::thread(&Recorder::serverWorker, this);
+      this->recordingThread = std::thread(&Recorder::recordingWorker, this);
+      this->toLog("Workers started");
+    }
+
+    Recorder::~Recorder()
+    {
+      wantsExit = true;
+      serverThread.join();
+      recordingThread.join();
+    }
+
+    void Recorder::setData(websocket::data &data)
+    {
+      const std::lock_guard<std::mutex> lock(mutex);
+
+      std::memcpy(&this->toSend, &data, sizeof(websocket::data));
+    }
+
+    void Recorder::handleMessages()
+    {
+      const std::lock_guard<std::mutex> lock(mutex);
+
+      if (!messageQueue().empty()) {
+        auto op = std::move(messageQueue().front());
+        messageQueue().pop();
+        op();
+      }
+    }
+
+    void Recorder::serverWorker()
+    {
+      utilities::setThreadName("GAServerWorker");
+
+      while (!wantsExit) {
+        struct websocket::data copy;
+        {
+          const std::lock_guard<std::mutex> lock(mutex);
+
+          std::memcpy(&copy, &toSend, sizeof(websocket::data));
+        }
+
+        connector->sendData(copy);
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(250));
+      }
+
+      toLog("Server thread stopped");
+    }
+
+    void Recorder::recordingWorker()
+    {
+      utilities::setThreadName("GARecordingWorker");
+
+      file::recording::Recording path;
+      file::recording::RecordingEntry lastPath;
+      std::uint32_t segment = 0;
+
+      while (!wantsExit) {
+        struct websocket::data copy;
+        {
+          const std::lock_guard<std::mutex> lock(mutex);
+
+          std::memcpy(&copy, &toSend, sizeof(websocket::data));
+        }
+
+        file::recording::RecordingEntry currentPath(
+            segment,
+            static_cast<std::uint16_t>(copy.alt),
+            static_cast<std::uint16_t>(copy.gs),
+            {copy.lat, copy.lon});
+
+        if (strcmp(copy.path, "") != 0 && copy.pause &&
+            lastPath != currentPath) {
+          path.addEntry(currentPath);
+          lastPath = currentPath;
+        }
+
+        segment++;
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+      }
+
+      path.toFile("flight.rec");
+      toLog("Recording thread stopped");
+    }
+
+    void Recorder::test() const
+    {
+#ifndef MSFS
+      this->toLog("Readback test of sim database using EDDF");
+      auto ap = (*this->database)["EDDF"];
+      for (const auto &it : ap.first) {
+        this->toLog("  " + it.to_string());
+      }
+      for (const auto &it : ap.second) {
+        this->toLog("  " + it.to_string());
+      }
+      this->toLog("Readback test of sim database using XXXX");
+      auto ap2 = (*database)["XXXX"];
+      ap2.first.size() == 0 ? this->toLog("  SUCCESS") : this->toLog("  ERROR");
+#endif
+      toLog("Logbook Test");
+      germanairlinesva::file::logbook::Logbook logbook;
+      logbook.addEntry("08.09.2022",
+                       "F",
+                       "1000",
+                       "L049",
+                       "D-ALFA",
+                       "John F. Kennedy International Aiport / EDDF",
+                       "A1",
+                       "14L",
+                       "Gander International Airport / CYQX",
+                       "10",
+                       "03",
+                       "10:00",
+                       "10:20",
+                       "13:20",
+                       "13:30",
+                       210.5,
+                       20.1,
+                       5012.4156,
+                       8.87,
+                       5041.3856,
+                       7.1,
+                       971.14,
+                       2.41,
+                       980.65,
+                       -165.23,
+                       1,
+                       1.2012,
+                       "2022-09-08_VGA1000",
+                       5.5,
+                       1);
+      logbook.toFile();
+    }
+  } // namespace recorder
+} // namespace gaconnector
+} // namespace germanairlinesva