Use Header Login

Failure Modes
Switch to use proxied wss

esp/CMakeLists.txt

@@ -1,17 +1,21 @@
 file(GLOB socket CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/websocket/*.cpp)
+file(GLOB recorder CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/recorder/*.cpp)
 
 enable_language(RC)
 
 # Add WIN32 to hide console window
 add_executable(germanairlinesva_esp WIN32
     ${socket}
+    ${recorder}
     resources/resources-${BIT}.rc
     simconnect.cpp
     main.cpp
 )
 
 target_include_directories(germanairlinesva_esp PRIVATE
+    ${CMAKE_SOURCE_DIR}/esp/include
     ${CMAKE_SOURCE_DIR}/file/include
+    ${CMAKE_SOURCE_DIR}/recorder/include
     ${CMAKE_SOURCE_DIR}/simdata/include
     ${CMAKE_SOURCE_DIR}/websocket/include
     ${CMAKE_SOURCE_DIR}/utilities/include

esp/include/_simconnect.h

@@ -57,21 +57,50 @@ struct data {
     double gForce; // G FORCE IN G
 };
 
-struct Port {
+struct port {
     double headingTrue; // PLANE HEADING DEGREES TRUE
     double latitude;    // PLANE LATITUDE
     double longitude;   // PLANE LONGITUDE
 };
 
+struct airport {
+    double lat;
+    double lon;
+    char name[32];
+};
+struct runway {
+    double lat;
+    double lon;
+    float heading;
+    float length;
+    float width;
+    int pNum;
+    int pDeg;
+    int sNum;
+    int sDeg;
+};
+struct parking {
+    int type;
+    int name;
+    int suffix;
+    unsigned int number;
+    float heading;
+    float radius;
+    float x;
+    float z;
+};
+
 #pragma pack(pop)
 
 enum DEFINITIONS {
   D_DATA,
+  D_FACILITY,
   D_PORT,
 };
 
 enum REQUESTS {
   R_DATA,
+  R_FACILITY,
   R_ACFT,
   R_DIALOG,
   R_PORT,
@@ -113,13 +142,17 @@ class SimConnect
     SimConnect(
         HWND hWnd,
         std::function<void(const std::string)> toLog,
-        std::shared_ptr<germanairlinesva::file::config::Config> &configuration);
+        std::shared_ptr<germanairlinesva::file::config::Config> configuration);
     ~SimConnect();
     bool isConnected() const;
-    const std::string getVersion() const;
+    char getVersion() const;
     void getData(struct germanairlinesva::gaconnector::websocket::data *data);
     void getStates() const;
-    void handleMessage();
+    void handleMessage(std::function<void(int)> callbackOpen,
+                       std::function<void()> callbackData);
+
+    static const std::string resolveVersion(char version);
+    static const std::string resolveScenery(char version);
 };
 
 #endif

esp/include/main.h

@@ -10,25 +10,19 @@
 #include <queue>
 #include <string>
 
+#include "constants.h"
+
 #include "websocket.h"
 
-#include <shlobj.h>
-#include <stdlib.h>
 #include <windows.h>
 
 #include "_simconnect.h"
-#include "config/config.hpp"
-#include "constants.h"
-#include "logbook/logbook.hpp"
-#include "recording/recording.hpp"
-#include "simdata/simDatabase.hpp"
+#include "recorder.h"
 
 WINBOOL addNotifyIcon(HWND hWnd);
 WINBOOL removeNotifyIcon(HWND hWnd);
 WINBOOL createMenu(HWND hWnd);
 void end(HWND hwnd);
-void serverWorker();
-void recordingWorker();
 void toLog(const std::string &message);
 
 #endif

esp/main.cpp

@@ -1,22 +1,8 @@
 #include "include/main.h"
 
-std::mutex mutex;
-std::queue<std::function<void()>> &messageQueue()
-{
-  static std::queue<std::function<void()>> _messageQueue;
-  return _messageQueue;
-}
-std::thread serverThread;
-std::thread recordingThread;
-std::atomic<bool> wantsExit;
-
-std::shared_ptr<germanairlinesva::file::config::Config> configuration;
-std::unique_ptr<germanairlinesva::file::simdata::SimDatabase> database;
-std::unique_ptr<germanairlinesva::gaconnector::websocket::Websocket> connector;
 std::unique_ptr<SimConnect> simConnect;
-
 struct germanairlinesva::gaconnector::websocket::data toSend;
-germanairlinesva::file::recording::Recording p;
+germanairlinesva::gaconnector::recorder::Recorder *recorder;
 
 // The Window Procedure
 LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
@@ -48,7 +34,14 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
     }
     case SIMCONNECT_MESSAGE: {
       if (simConnect != nullptr && simConnect->isConnected()) {
-        simConnect->handleMessage();
+        simConnect->handleMessage(
+            [](int version) { recorder->loadDatabase(version); },
+            []() {
+              germanairlinesva::gaconnector::websocket::data d;
+              simConnect->getStates();
+              simConnect->getData(&d);
+              recorder->setData(d);
+            });
       }
       break;
     }
@@ -74,8 +67,6 @@ int WINAPI WinMain(HINSTANCE hInstance,
   HWND hWnd;
   MSG msg;
 
-  wantsExit.store(false);
-
   // Exit if already running
   hWnd = FindWindow(WINDOW_CLASS, WINDOW_CLASS);
   if (hWnd != NULL) {
@@ -124,100 +115,11 @@ int WINAPI WinMain(HINSTANCE hInstance,
   // Never show window
   // ShowWindow(hWnd, SHOW_OPENWINDOW);
 
-  configuration = std::make_unique<germanairlinesva::file::config::Config>();
-  toLog("Config loaded");
-
-  connector =
-      std::make_unique<germanairlinesva::gaconnector::websocket::Websocket>(
-          "wss://ws.hofmannnet.myhome-server.de:8000",
-          configuration->getUser(),
-          toLog);
-  toLog("WebSocket started");
-
-#ifndef MSFS
-  PWSTR folder;
-  HRESULT result = SHGetKnownFolderPath(FOLDERID_RoamingAppData,
-                                        KF_FLAG_DEFAULT,
-                                        NULL,
-                                        &folder);
-  if (SUCCEEDED(result)) {
-    size_t origsize = wcslen(folder) + 1;
-    size_t convertedChars = 0;
-    char *nstring = new char[origsize * 2];
-    wcstombs_s(&convertedChars, nstring, origsize * 2, folder, _TRUNCATE);
-
-    std::string path(nstring);
-    path.append("\\Microsoft\\FSX\\scenery.cfg");
-    toLog(path);
-
-    delete[] nstring;
-    CoTaskMemFree(folder);
-
-    char hash[2 * MD5LEN + 1] = "";
-    if (germanairlinesva::utilities::generateMD5(path.c_str(), hash, toLog) ==
-        0) {
-      database = std::make_unique<germanairlinesva::file::simdata::SimDatabase>(
-          FSX_VERSION,
-          hash,
-          configuration,
-          toLog);
-    }
-
-    toLog("Readback test of sim database using EDDF");
-    auto ap = (*database)["EDDF"];
-    for (const auto &it : ap.first) {
-      toLog("  " + it.to_string());
-    }
-    for (const auto &it : ap.second) {
-      toLog("  " + it.to_string());
-    }
-    toLog("Readback test of sim database using XXXX");
-    auto ap2 = (*database)["XXXX"];
-    ap2.first.size() == 0 ? toLog("  SUCCESS") : 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();
+  recorder = new germanairlinesva::gaconnector::recorder::Recorder(0, toLog);
 
   // Open SimConnect
-  simConnect = std::make_unique<SimConnect>(hWnd, toLog, configuration);
-
-  // Thread for sending data to websocket
-  serverThread = std::thread(&serverWorker);
-  recordingThread = std::thread(&recordingWorker);
-  toLog("Workers started");
+  simConnect =
+      std::make_unique<SimConnect>(hWnd, toLog, recorder->getConfiguration());
 
   // The Message Loop
   while (GetMessage(&msg, NULL, 0, 0) > 0) {
@@ -244,7 +146,7 @@ WINBOOL addNotifyIcon(HWND hWnd)
                           GetSystemMetrics(SM_CYSMICON),
                           LR_SHARED);
   if (icon == NULL) {
-    toLog("error icon " + std::to_string(GetLastError()));
+    toLog("Error icon " + std::to_string(GetLastError()));
   }
   niData.cbSize = sizeof(NOTIFYICONDATA);
   niData.uVersion = NOTIFYICON_VERSION_4;
@@ -282,9 +184,12 @@ WINBOOL createMenu(HWND hWnd)
   AppendMenu(hMenu, MF_STRING | MF_GRAYED, NULL, "Version: " BIT " Bit");
   if (simConnect->isConnected()) {
     std::string version("Connected to Sim: ");
-    version.append(simConnect->getVersion());
+    version.append(SimConnect::resolveVersion(simConnect->getVersion()));
     AppendMenu(hMenu, MF_STRING | MF_GRAYED, NULL, version.c_str());
   }
+  if (!recorder->getSupportedState()) {
+    AppendMenu(hMenu, MF_STRING | MF_GRAYED, NULL, "Sim unsupported");
+  }
   AppendMenu(hMenu, MF_SEPARATOR, NULL, NULL);
   AppendMenu(hMenu, MF_STRING, IDM_EXIT, "Exit");
 
@@ -312,11 +217,7 @@ void end(HWND hWnd)
   UnregisterClass(WINDOW_CLASS, GetModuleHandle(NULL));
 
   /* End threads */
-  wantsExit = true;
-  serverThread.join();
-  recordingThread.join();
-
-  p.toFile("flight.rec");
+  recorder->~Recorder();
 
   // End SimConnect
   delete simConnect.release();
@@ -324,74 +225,6 @@ void end(HWND hWnd)
   PostQuitMessage(0);
 }
 
-void serverWorker()
-{
-  germanairlinesva::utilities::setThreadName("GAServerWorker");
-
-  while (!wantsExit) {
-    simConnect->getStates();
-
-    struct germanairlinesva::gaconnector::websocket::data *copy =
-        new germanairlinesva::gaconnector::websocket::data();
-    {
-      const std::lock_guard<std::mutex> lock(mutex);
-
-      simConnect->getData(copy);
-    }
-
-    connector->sendData(*copy);
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(250));
-  }
-
-  toLog("Server thread stopped");
-}
-
-void recordingWorker()
-{
-  germanairlinesva::utilities::setThreadName("GARecordingWorker");
-
-  germanairlinesva::file::recording::RecordingEntry lastPath;
-  std::uint32_t segment = 0;
-
-  auto ap = (*database)["EDDF"];
-  auto rwys = ap.second;
-
-  while (!wantsExit) {
-    struct germanairlinesva::gaconnector::websocket::data *copy =
-        new germanairlinesva::gaconnector::websocket::data();
-    {
-      const std::lock_guard<std::mutex> lock(mutex);
-
-      simConnect->getData(copy);
-    }
-
-    germanairlinesva::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) {
-      p.addEntry(currentPath);
-      lastPath = currentPath;
-
-      for (const auto &it : rwys) {
-        if (it.containsPoint({copy->lat, copy->lon})) {
-          toLog("On Runway: " + it.to_string());
-        }
-      }
-    }
-
-    segment++;
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-  }
-
-  toLog("Recording thread stopped");
-}
-
 void toLog(const std::string &message)
 {
   std::time_t utc = std::time(nullptr);

esp/simconnect.cpp

@@ -3,7 +3,7 @@
 SimConnect::SimConnect(
     HWND hWnd,
     std::function<void(const std::string)> toLog,
-    std::shared_ptr<germanairlinesva::file::config::Config> &configuration)
+    std::shared_ptr<germanairlinesva::file::config::Config> configuration)
     : configuration(configuration), toLog(std::move(toLog))
 {
   HRESULT hr = SimConnect_Open(&this->simConnect,
@@ -19,48 +19,52 @@ SimConnect::SimConnect(
     this->toLog("SimConnect_Close: Connection opened");
 
     // Setup SimConnect
-    SimConnect_SubscribeToSystemEvent(simConnect, EVENTS::E_PAUSE, "Pause");
-    SimConnect_SubscribeToSystemEvent(simConnect, EVENTS::E_STATUS, "Sim");
+    SimConnect_SubscribeToSystemEvent(this->simConnect,
+                                      EVENTS::E_PAUSE,
+                                      "Pause");
+    SimConnect_SubscribeToSystemEvent(this->simConnect,
+                                      EVENTS::E_STATUS,
+                                      "Sim");
 
-    SimConnect_MapClientEventToSimEvent(simConnect,
+    SimConnect_MapClientEventToSimEvent(this->simConnect,
                                         EVENTS::E_TIMESEC,
                                         "CLOCK_SECONDS_ZERO");
-    SimConnect_AddClientEventToNotificationGroup(simConnect,
+    SimConnect_AddClientEventToNotificationGroup(this->simConnect,
                                                  GROUPS::G_TIME,
                                                  EVENTS::E_TIMESEC,
                                                  false);
-    SimConnect_SetNotificationGroupPriority(simConnect,
+    SimConnect_SetNotificationGroupPriority(this->simConnect,
                                             GROUPS::G_TIME,
                                             SIMCONNECT_GROUP_PRIORITY_HIGHEST);
-    SimConnect_MapClientEventToSimEvent(simConnect,
+    SimConnect_MapClientEventToSimEvent(this->simConnect,
                                         EVENTS::E_TIMEMIN,
                                         "ZULU_MINUTES_SET");
-    SimConnect_AddClientEventToNotificationGroup(simConnect,
+    SimConnect_AddClientEventToNotificationGroup(this->simConnect,
                                                  GROUPS::G_TIME,
                                                  EVENTS::E_TIMEMIN,
                                                  false);
-    SimConnect_SetNotificationGroupPriority(simConnect,
+    SimConnect_SetNotificationGroupPriority(this->simConnect,
                                             GROUPS::G_TIME,
                                             SIMCONNECT_GROUP_PRIORITY_HIGHEST);
-    SimConnect_MapClientEventToSimEvent(simConnect,
+    SimConnect_MapClientEventToSimEvent(this->simConnect,
                                         EVENTS::E_TIMEHRS,
                                         "ZULU_HOURS_SET");
-    SimConnect_AddClientEventToNotificationGroup(simConnect,
+    SimConnect_AddClientEventToNotificationGroup(this->simConnect,
                                                  GROUPS::G_TIME,
                                                  EVENTS::E_TIMEHRS,
                                                  false);
-    SimConnect_SetNotificationGroupPriority(simConnect,
+    SimConnect_SetNotificationGroupPriority(this->simConnect,
                                             GROUPS::G_TIME,
                                             SIMCONNECT_GROUP_PRIORITY_HIGHEST);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "BRAKE PARKING INDICATOR",
                                    "BOOL",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "SIM ON GROUND",
                                    "BOOL",
@@ -68,14 +72,14 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "EMPTY WEIGHT",
                                    "KILOGRAMS",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "TOTAL WEIGHT",
                                    "KILOGRAMS",
@@ -83,7 +87,7 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "FUEL TOTAL QUANTITY WEIGHT",
                                    "KILOGRAMS",
@@ -91,14 +95,14 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "PLANE HEADING DEGREES TRUE",
                                    "DEGREES",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "PLANE HEADING DEGREES MAGNETIC",
                                    "DEGREES",
@@ -106,21 +110,21 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "GROUND VELOCITY",
                                    "KNOTS",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "AIRSPEED INDICATED",
                                    "KNOTS",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "AIRSPEED BARBER POLE",
                                    "KNOTS",
@@ -128,28 +132,28 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "VELOCITY WORLD Y",
                                    "FEET/MINUTE",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "VERTICAL SPEED",
                                    "FEET/MINUTE",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "PLANE ALTITUDE",
                                    "FEET",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "PLANE ALT ABOVE GROUND",
                                    "FEET",
@@ -157,14 +161,14 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "PLANE LATITUDE",
                                    "DEGREES",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "PLANE LONGITUDE",
                                    "DEGREES",
@@ -172,7 +176,7 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "ABSOLUTE TIME",
                                    "SECONDS",
@@ -180,28 +184,28 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "ENG FUEL FLOW PPH:1",
                                    "KILOGRAMS PER SECOND",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "ENG FUEL FLOW PPH:2",
                                    "KILOGRAMS PER SECOND",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "ENG FUEL FLOW PPH:3",
                                    "KILOGRAMS PER SECOND",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "ENG FUEL FLOW PPH:4",
                                    "KILOGRAMS PER SECOND",
@@ -209,21 +213,21 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "BRAKE INDICATOR",
                                    "POSITION",
                                    SIMCONNECT_DATATYPE_INT32,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "BRAKE PARKING POSITION",
                                    "POSITION",
                                    SIMCONNECT_DATATYPE_INT32,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "BRAKE LEFT POSITION",
                                    "POSITION",
@@ -231,7 +235,7 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "ZULU TIME",
                                    "SECONDS",
@@ -239,7 +243,7 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_DATA,
                                    "G FORCE",
                                    "GForce",
@@ -247,21 +251,21 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_PORT,
                                    "PLANE HEADING DEGREES TRUE",
                                    "DEGREES",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_PORT,
                                    "PLANE LATITUDE",
                                    "DEGREES",
                                    SIMCONNECT_DATATYPE_FLOAT64,
                                    0,
                                    SIMCONNECT_UNUSED);
-    SimConnect_AddToDataDefinition(simConnect,
+    SimConnect_AddToDataDefinition(this->simConnect,
                                    DEFINITIONS::D_PORT,
                                    "PLANE LONGITUDE",
                                    "DEGREES",
@@ -269,7 +273,67 @@ SimConnect::SimConnect(
                                    0,
                                    SIMCONNECT_UNUSED);
 
-    SimConnect_RequestDataOnSimObject(simConnect,
+#ifdef MSFS
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "OPEN AIRPORT");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "LATITUDE");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "LONGITUDE");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "NAME");
+
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "OPEN RUNWAY");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "LATITUDE");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "LONGITUDE");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "HEADING");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "LENGTH");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "WIDTH");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "PRIMARY_NUMBER");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "PRIMARY_DESIGNATOR");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "SECONDARY_NUMBER");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "SECONDARY_DESIGNATOR");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "CLOSE RUNWAY");
+
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "OPEN TAXI_PARKING");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "TYPE");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "NAME");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "SUFFIX");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "NUMBER");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "HEADING");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "RADIUS");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "BIAS_X");
+    SimConnect_AddToFacilityDefinition(this->simConnect, D_FACILITY, "BIAS_Z");
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "CLOSE TAXI_PARKING");
+
+    SimConnect_AddToFacilityDefinition(this->simConnect,
+                                       D_FACILITY,
+                                       "CLOSE AIRPORT");
+#endif
+
+    SimConnect_RequestDataOnSimObject(this->simConnect,
                                       REQUESTS::R_DATA,
                                       DEFINITIONS::D_DATA,
                                       SIMCONNECT_OBJECT_ID_USER,
@@ -304,24 +368,7 @@ void SimConnect::getStates() const
 
 bool SimConnect::isConnected() const { return this->connectedToSim; }
 
-const std::string SimConnect::getVersion() const
-{
-  switch (this->version) {
-    case MSFS_VERSION:
-      return "MSFS";
-    case FSX_VERSION:
-      return "FSX";
-    case P3D5_VERSION:
-      return "P3D5";
-    case P3D4_VERSION:
-      return "P3D4";
-      break;
-    case P3D3_VERSION:
-      return "P3D3";
-    default:
-      return "Unknown";
-  }
-}
+char SimConnect::getVersion() const { return this->version; }
 
 void SimConnect::getData(
     struct germanairlinesva::gaconnector::websocket::data *data)
@@ -330,7 +377,8 @@ void SimConnect::getData(
   memcpy(data, &this->simData, sizeof(this->simData));
 }
 
-void SimConnect::handleMessage()
+void SimConnect::handleMessage(std::function<void(int)> callbackOpen,
+                               std::function<void()> callbackData)
 {
   SIMCONNECT_RECV *pData;
   DWORD cbData;
@@ -340,6 +388,7 @@ void SimConnect::handleMessage()
     switch (pData->dwID) {
       case SIMCONNECT_RECV_ID_OPEN: {
         this->handleOpen((SIMCONNECT_RECV_OPEN *)pData);
+        callbackOpen(this->version);
         break;
       }
       case SIMCONNECT_RECV_ID_EVENT: {
@@ -352,8 +401,14 @@ void SimConnect::handleMessage()
       }
       case SIMCONNECT_RECV_ID_SIMOBJECT_DATA: {
         this->handleData((SIMCONNECT_RECV_SIMOBJECT_DATA *)pData);
+        callbackData();
         break;
       }
+#ifdef MSFS
+      case SIMCONNECT_RECV_ID_FACILITY_DATA: {
+        this->toLog("NavData API MSFS Message received");
+      }
+#endif
       default:
         break;
     }
@@ -379,7 +434,7 @@ void SimConnect::handleOpen(SIMCONNECT_RECV_OPEN *data)
           this->version = FSX_VERSION;
           break;
         case FSXSE_SUBVERSION:
-          if (configuration->getFSXSEPath().length() > 0) {
+          if (configuration->getPath(FSXSE_VERSION).length() > 0) {
             this->version = FSXSE_VERSION;
           } else {
             this->version = FSX_VERSION;
@@ -458,3 +513,41 @@ void SimConnect::handleData(SIMCONNECT_RECV_SIMOBJECT_DATA *data)
     }
   }
 }
+
+const std::string SimConnect::resolveVersion(char version)
+{
+  switch (version) {
+    case MSFS_VERSION:
+      return "MSFS";
+    case FSX_VERSION:
+      return "FSX";
+    case P3D5_VERSION:
+      return "P3D5";
+    case P3D4_VERSION:
+      return "P3D4";
+      break;
+    case P3D3_VERSION:
+      return "P3D3";
+    default:
+      return "Unknown";
+  }
+}
+
+const std::string SimConnect::resolveScenery(char version)
+{
+  switch (version) {
+    case FSX_VERSION:
+      return FSX_SCENERY;
+    case FSXSE_VERSION:
+      return FSXSE_SCENERY;
+    case P3D5_VERSION:
+      return P3D5_SCENREY;
+    case P3D4_VERSION:
+      return P3D4_SCENREY;
+      break;
+    case P3D3_VERSION:
+      return P3D3_SCENREY;
+    default:
+      return "/";
+  }
+}

file/include/config/config.hpp

@@ -21,7 +21,13 @@ namespace file
     {
       private:
         std::string user;
-        std::string scenery;
+        std::string XP11Scenery;
+        std::string XP12Scenery;
+        std::string FSXScenery;
+        std::string FSXSEScenery;
+        std::string P3D3Scenery;
+        std::string P3D4Scenery;
+        std::string P3D5Scenery;
         std::string token;
         std::string FSXPath;
         std::string FSXSEPath;
@@ -33,7 +39,13 @@ namespace file
         inline void writeFile() const
         {
           std::ofstream out(BASE_DIRECTORY CONFIG);
-          out << "scenery=" << this->scenery << "\n";
+          out << "xp11Scenery=" << this->XP11Scenery << "\n";
+          out << "xp12Scenery=" << this->XP12Scenery << "\n";
+          out << "fsxScenery=" << this->FSXScenery << "\n";
+          out << "fsxSEScenery=" << this->FSXSEScenery << "\n";
+          out << "p3d3Scenery=" << this->P3D3Scenery << "\n";
+          out << "p3d4Scenery=" << this->P3D4Scenery << "\n";
+          out << "p3d5Scenery=" << this->P3D5Scenery << "\n";
           out << "user=" << this->user << "\n";
           out << "token=" << this->token << "\n";
           out << "fsxPath=" << this->FSXPath << "\n";
@@ -55,8 +67,20 @@ namespace file
             if (fields.size() >= 2) {
               utilities::trim(fields[0]);
               utilities::trim(fields[1]);
-              if (fields[0] == "scenery") {
-                this->scenery = fields[1];
+              if (fields[0] == "xp11Scenery") {
+                this->XP11Scenery = fields[1];
+              } else if (fields[0] == "xp12Scenery") {
+                this->XP12Scenery = fields[1];
+              } else if (fields[0] == "fsxScenery") {
+                this->FSXScenery = fields[1];
+              } else if (fields[0] == "fsxSEScenery") {
+                this->FSXSEScenery = fields[1];
+              } else if (fields[0] == "p3d3Scenery") {
+                this->P3D3Scenery = fields[1];
+              } else if (fields[0] == "p3d4Scenery") {
+                this->P3D4Scenery = fields[1];
+              } else if (fields[0] == "p3d5Scenery") {
+                this->P3D5Scenery = fields[1];
               } else if (fields[0] == "user") {
                 this->user = fields[1];
               } else if (fields[0] == "token") {
@@ -79,25 +103,78 @@ namespace file
           in.close();
         }
 
-        inline void updateScenery(std::string scenery)
+        inline void updateScenery(int simVersion, std::string scenery)
         {
-          this->scenery = scenery;
+          switch (simVersion) {
+            case FSX_VERSION:
+              this->FSXScenery = scenery;
+              break;
+            case FSXSE_VERSION:
+              this->FSXSEScenery = scenery;
+              break;
+            case P3D3_VERSION:
+              this->P3D3Scenery = scenery;
+              break;
+            case P3D4_VERSION:
+              this->P3D4Scenery = scenery;
+              break;
+            case P3D5_VERSION:
+              this->P3D5Scenery = scenery;
+              break;
+            default:
+              if (simVersion < 12000) {
+                this->XP11Scenery = scenery;
+              } else {
+                this->XP12Scenery = scenery;
+              }
+              break;
+          }
 
           this->writeFile();
         }
 
         inline const std::string getUser() const { return this->user; }
-        inline const std::string getScenery() const { return this->scenery; }
-        inline const std::string getToken() const { return this->token; }
-        inline const std::string getFSXPath() const { return this->FSXPath; }
-        inline const std::string getFSXSEPath() const
+        inline const std::string getScenery(int simVersion) const
         {
-          return this->FSXSEPath;
+          switch (simVersion) {
+            case FSX_VERSION:
+              return this->FSXScenery;
+            case FSXSE_VERSION:
+              return this->FSXSEScenery;
+            case P3D3_VERSION:
+              return this->P3D3Scenery;
+            case P3D4_VERSION:
+              return this->P3D4Scenery;
+            case P3D5_VERSION:
+              return this->P3D5Scenery;
+            default:
+              if (simVersion < 12000) {
+                return this->XP11Scenery;
+              } else {
+                return this->XP12Scenery;
+              }
+          }
+        }
+        inline const std::string getToken() const { return this->token; }
+        inline const std::string getPath(int simVersion) const
+        {
+          switch (simVersion) {
+            case FSX_VERSION:
+              return this->FSXPath;
+            case FSXSE_VERSION:
+              return this->FSXSEPath;
+            case P3D3_VERSION:
+              return this->P3D3Path;
+            case P3D4_VERSION:
+              return this->P3D4Path;
+            case P3D5_VERSION:
+              return this->P3D5Path;
+            case MSFS_VERSION:
+              return this->MSFSPath;
+            default:
+              return "/";
+          }
         }
-        inline const std::string getP3D3Path() const { return this->P3D3Path; }
-        inline const std::string getP3D4Path() const { return this->P3D4Path; }
-        inline const std::string getP3D5Path() const { return this->P3D5Path; }
-        inline const std::string getMSFSPath() const { return this->MSFSPath; }
     };
   } // namespace config
 } // namespace file

file/include/simdata/simDatabase.hpp

@@ -91,10 +91,8 @@ namespace file
           in.close();
         }
 
-        inline void fromFile(const char *file)
+        inline void fromFile(const char *path)
         {
-          std::string path(BASE_DIRECTORY);
-          path.append(file);
           std::ifstream in(path, std::ifstream::binary);
 
           std::string ident = readString(in, 4);
@@ -108,82 +106,8 @@ namespace file
           }
         }
 
-      public:
-        inline SimDatabase(int simVersion,
-                           const char *hash,
-                           std::shared_ptr<config::Config> &configuration,
-                           std::function<void(const std::string)> toLog)
+        inline void toFile(const char *path) const
         {
-          if (strcmp(configuration->getScenery().c_str(), hash) != 0 ||
-              !utilities::fileExists(BASE_DIRECTORY SIMDATABASE)) {
-#ifdef XP
-            scan(simVersion < 12000 ? XPLANE11_BASE_SCENERY
-                                    : XPLANE12_BASE_SCENERY,
-                 XPLANE_CUSTOM_SCENERY,
-                 BASE_DIRECTORY "log.txt",
-                 airports);
-#endif
-#ifndef MSFS
-            scan(BASE_DIRECTORY MAKERWYS_R5,
-                 BASE_DIRECTORY MAKERWYS_G5,
-                 BASE_DIRECTORY "db_log.txt",
-                 airports);
-#endif
-            configuration->updateScenery(hash);
-#ifdef XP
-            this->toFile(SIMDATABASE);
-#endif
-#ifndef MSFS
-            switch (simVersion) {
-              case FSX_VERSION:
-                this->toFile(FSX_PREFIX SIMDATABASE);
-                break;
-              case FSXSE_VERSION:
-                this->toFile(FSXSE_PREFIX SIMDATABASE);
-                break;
-              case P3D3_VERSION:
-                this->toFile(P3D3_PREFIX SIMDATABASE);
-                break;
-              case P3D4_VERSION:
-                this->toFile(P3D4_PREFIX SIMDATABASE);
-                break;
-              case P3D5_VERSION:
-                this->toFile(P3D5_PREFIX SIMDATABASE);
-                break;
-            }
-#endif
-            toLog("Sim Database updated");
-          } else {
-#ifdef XP
-            this->fromFile(SIMDATABASE);
-#endif
-#ifndef MSFS
-            switch (simVersion) {
-              case FSX_VERSION:
-                this->fromFile(FSX_PREFIX SIMDATABASE);
-                break;
-              case FSXSE_VERSION:
-                this->fromFile(FSXSE_PREFIX SIMDATABASE);
-                break;
-              case P3D3_VERSION:
-                this->fromFile(P3D3_PREFIX SIMDATABASE);
-                break;
-              case P3D4_VERSION:
-                this->fromFile(P3D4_PREFIX SIMDATABASE);
-                break;
-              case P3D5_VERSION:
-                this->fromFile(P3D5_PREFIX SIMDATABASE);
-                break;
-            }
-#endif
-            toLog("Sim Database loaded");
-          }
-        }
-
-        inline void toFile(const char *file) const
-        {
-          std::string path(BASE_DIRECTORY);
-          path.append(file);
           std::ofstream out(path, std::fstream::binary);
 
           // File Header
@@ -215,6 +139,63 @@ namespace file
           out.close();
         }
 
+        inline const char *resolveFilename(int simVersion) const
+        {
+          switch (simVersion) {
+            case FSX_VERSION:
+              return BASE_DIRECTORY FSX_PREFIX SIMDATABASE;
+            case FSXSE_VERSION:
+              return BASE_DIRECTORY FSXSE_PREFIX SIMDATABASE;
+            case P3D3_VERSION:
+              return BASE_DIRECTORY P3D3_PREFIX SIMDATABASE;
+            case P3D4_VERSION:
+              return BASE_DIRECTORY P3D4_PREFIX SIMDATABASE;
+            case P3D5_VERSION:
+              return BASE_DIRECTORY P3D5_PREFIX SIMDATABASE;
+            case MSFS_VERSION:
+              return "NONE";
+            default:
+              return BASE_DIRECTORY SIMDATABASE;
+          }
+        }
+
+      public:
+        inline SimDatabase(int simVersion,
+                           const char *hash,
+                           std::shared_ptr<config::Config> &configuration,
+                           std::function<void(const std::string)> toLog)
+        {
+          if (strcmp(configuration->getScenery(simVersion).c_str(), hash) !=
+                  0 ||
+              !utilities::fileExists(resolveFilename(simVersion))) {
+#ifdef XP
+            scan(simVersion < 12000 ? XPLANE11_BASE_SCENERY
+                                    : XPLANE12_BASE_SCENERY,
+                 XPLANE_CUSTOM_SCENERY,
+                 BASE_DIRECTORY "log.txt",
+                 airports);
+#endif
+#ifndef MSFS
+            scan(BASE_DIRECTORY MAKERWYS_R5,
+                 BASE_DIRECTORY MAKERWYS_G5,
+                 BASE_DIRECTORY "db_log.txt",
+                 airports);
+#endif
+            configuration->updateScenery(simVersion, hash);
+
+#ifndef MSFS
+            this->toFile(resolveFilename(simVersion));
+#endif
+            toLog("Sim Database updated");
+          } else {
+
+#ifndef MSFS
+            this->fromFile(resolveFilename(simVersion));
+#endif
+            toLog("Sim Database loaded");
+          }
+        }
+
         inline std::size_t getCount() const { return this->airports.size(); }
 
         inline const std::pair<const std::vector<Gate>,

recorder/include/recorder.h

@@ -7,8 +7,18 @@
 #include <queue>
 #include <thread>
 
+#include "constants.h"
+
 #include "websocket.h"
 
+#if defined(IBM) && not defined(XP)
+#include "_simconnect.h"
+
+#include <shlobj.h>
+#include <stdlib.h>
+#include <windows.h>
+#endif
+
 #include "config/config.hpp"
 #include "logbook/logbook.hpp"
 #include "recording/recording.hpp"
@@ -35,6 +45,7 @@ namespace gaconnector
         std::unique_ptr<websocket::Websocket> connector;
 
         websocket::data toSend;
+        bool simSupported = false;
 
         std::queue<std::function<void()>> &messageQueue()
         {
@@ -45,6 +56,7 @@ namespace gaconnector
         void serverWorker();
         void recordingWorker();
 
+
         // For Testing
         void test() const;
 
@@ -54,6 +66,9 @@ namespace gaconnector
 
         void setData(websocket::data &data);
         void handleMessages();
+        std::shared_ptr<file::config::Config> getConfiguration() const;
+        void loadDatabase(int simVersion);
+        bool getSupportedState() const;
     };
   } // namespace recorder
 } // namespace gaconnector

recorder/recorder.cpp

@@ -6,6 +6,8 @@ namespace gaconnector
 {
   namespace recorder
   {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
     Recorder::Recorder(int simVersion,
                        std::function<void(const std::string)> toLog)
         : toLog(std::move(toLog))
@@ -15,9 +17,66 @@ namespace gaconnector
       this->toLog("Configuration loaded");
 
 // Database
+#ifdef XP
+      this->loadDatabase(simVersion);
+#endif
+
+      // WebSocket
+      this->connector =
+          std::make_unique<websocket::Websocket>(WEBSOCKET_ADDRESS,
+                                                 this->configuration->getUser(),
+                                                 this->configuration->getToken(),
+                                                 this->toLog);
+      this->toLog("WebSocket started");
+
+// For Testing
+#ifdef XP
+      this->test();
+#endif
+
+      // Thread for sending data to websocket
+      this->serverThread = std::thread(&Recorder::serverWorker, this);
+      this->recordingThread = std::thread(&Recorder::recordingWorker, this);
+      this->toLog("Workers started");
+    }
+#pragma clang diagnostic pop
+
+    Recorder::~Recorder()
+    {
+      this->wantsExit.store(true);
+      this->serverThread.join();
+      this->recordingThread.join();
+    }
+
+    void Recorder::setData(websocket::data &data)
+    {
+      const std::lock_guard<std::mutex> lock(this->mutex);
+
+      std::memcpy(&this->toSend, &data, sizeof(websocket::data));
+    }
+
+    void Recorder::handleMessages()
+    {
+      const std::lock_guard<std::mutex> lock(this->mutex);
+
+      if (!this->messageQueue().empty()) {
+        auto op = std::move(this->messageQueue().front());
+        this->messageQueue().pop();
+        op();
+      }
+    }
+
+    std::shared_ptr<file::config::Config> Recorder::getConfiguration() const
+    {
+      return this->configuration;
+    }
+
+    void Recorder::loadDatabase(int simVersion)
+    {
 #ifdef XP
       char hash[2 * MD5LEN + 1] = "";
-      if (utilities::generateMD5(XPLANE_CUSTOM_SCENERY, hash, toLog) == 0) {
+      if (utilities::generateMD5(XPLANE_CUSTOM_SCENERY, hash, this->toLog) ==
+          0) {
         this->database =
             std::make_unique<file::simdata::SimDatabase>(simVersion,
                                                          hash,
@@ -25,49 +84,52 @@ namespace gaconnector
                                                          this->toLog);
       }
 #endif
-#ifndef MSFS
+
+#if defined(IBM) && not defined(XP)
+      if (simVersion == MSFS_VERSION) {
+        this->simSupported = strcmp(BIT, "64") == 0;
+        return;
+      }
+
+      this->toLog("Loading database for " +
+                  SimConnect::resolveVersion(simVersion));
+
+      PWSTR folder;
+      HRESULT result = SHGetKnownFolderPath(FOLDERID_RoamingAppData,
+                                            KF_FLAG_DEFAULT,
+                                            NULL,
+                                            &folder);
+      if (SUCCEEDED(result)) {
+        size_t origsize = wcslen(folder) + 1;
+        size_t convertedChars = 0;
+        char *nstring = new char[origsize * 2];
+        wcstombs_s(&convertedChars, nstring, origsize * 2, folder, _TRUNCATE);
+
+        std::string path(nstring);
+        path.append(SimConnect::resolveScenery(simVersion));
+        this->toLog("Scenery path: " + path);
+
+        delete[] nstring;
+        CoTaskMemFree(folder);
+
+        char hash[2 * MD5LEN + 1] = "";
+        if (utilities::generateMD5(path.c_str(), hash, toLog) == 0) {
+          this->database =
+              std::make_unique<file::simdata::SimDatabase>(simVersion,
+                                                           hash,
+                                                           this->configuration,
+                                                           this->toLog);
+        }
+
+        this->test();
+      }
 #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");
+      // Only here can we be sure to have a supported sim
+      this->simSupported = true;
     }
 
-    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();
-      }
-    }
+    bool Recorder::getSupportedState() const { return this->simSupported; }
 
     void Recorder::serverWorker()
     {
@@ -76,17 +138,17 @@ namespace gaconnector
       while (!wantsExit) {
         struct websocket::data copy;
         {
-          const std::lock_guard<std::mutex> lock(mutex);
+          const std::lock_guard<std::mutex> lock(this->mutex);
 
-          std::memcpy(&copy, &toSend, sizeof(websocket::data));
+          std::memcpy(&copy, &this->toSend, sizeof(websocket::data));
         }
 
-        connector->sendData(copy);
+        this->connector->sendData(copy);
 
         std::this_thread::sleep_for(std::chrono::milliseconds(250));
       }
 
-      toLog("Server thread stopped");
+      this->toLog("Server thread stopped");
     }
 
     void Recorder::recordingWorker()
@@ -100,9 +162,9 @@ namespace gaconnector
       while (!wantsExit) {
         struct websocket::data copy;
         {
-          const std::lock_guard<std::mutex> lock(mutex);
+          const std::lock_guard<std::mutex> lock(this->mutex);
 
-          std::memcpy(&copy, &toSend, sizeof(websocket::data));
+          std::memcpy(&copy, &this->toSend, sizeof(websocket::data));
         }
 
         file::recording::RecordingEntry currentPath(
@@ -111,7 +173,7 @@ namespace gaconnector
             static_cast<std::uint16_t>(copy.gs),
             {copy.lat, copy.lon});
 
-        if (strcmp(copy.path, "") != 0 && copy.pause &&
+        if (strcmp(copy.path, "") != 0 && !copy.pause &&
             lastPath != currentPath) {
           path.addEntry(currentPath);
           lastPath = currentPath;
@@ -123,7 +185,7 @@ namespace gaconnector
       }
 
       path.toFile("flight.rec");
-      toLog("Recording thread stopped");
+      this->toLog("Recording thread stopped");
     }
 
     void Recorder::test() const
@@ -141,39 +203,6 @@ namespace gaconnector
       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

utilities/include/constants.h

@@ -63,6 +63,12 @@
 #define P3D5_VERSION 5
 #define MSFS_VERSION 11
 
+#define FSX_SCENERY "\\Microsoft\\FSX\\scenery.cfg"
+#define FSXSE_SCENERY "\\Microsoft\\FSX-SE\\scenery.cfg"
+#define P3D3_SCENREY "\\Lockheed Martin\\Prepar3D V3\\scenery.cfg"
+#define P3D4_SCENREY "\\Lockheed Martin\\Prepar3D V4\\scenery.cfg"
+#define P3D5_SCENREY "\\Lockheed Martin\\Prepar3D V5\\scenery.cfg"
+
 // Not supported
 #define FSXRTM_SUBVERSION 60905
 #define FSSXSP1_SUBVERRSION 61242
@@ -73,4 +79,6 @@
 // Must be differentiated due to SxS Install
 #define FSXSE_SUBVERSION 62615
 
+#define WEBSOCKET_ADDRESS "wss://wsecho.hofmannnet.myhome-server.de/ws"
+
 #endif

websocket/include/types.h

@@ -56,6 +56,13 @@ namespace gaconnector
         float trueHeading;
     };
 
+    enum failures {
+      NONE,
+      AUTH,
+      DUPLICATESIM,
+      OTHER,
+    };
+
 #pragma pack(pop) /* restore original alignment from stack */
   }               // namespace websocket
 } // namespace gaconnector

websocket/include/websocket.h

@@ -27,16 +27,20 @@ namespace gaconnector
     class Websocket
     {
       private:
+        bool isLoggedIn = false;
+        enum failures failureMode = failures::NONE;
         char lastPath[513] = "";
         char lastHash[2 * MD5LEN + 1] = "";
         ix::WebSocket *webSocket = nullptr;
         std::string host;
         std::string user;
+        std::string token;
         std::function<void(const std::string)> toLog;
 
       public:
         Websocket(std::string host,
                   std::string user,
+                  std::string token,
                   std::function<void(const std::string)> toLog);
         ~Websocket();
         void onClientMessageCallback(const ix::WebSocketMessagePtr &msg);

websocket/websocket.cpp

@@ -8,8 +8,9 @@ namespace gaconnector
   {
     Websocket::Websocket(std::string host,
                          std::string user,
+                         std::string token,
                          std::function<void(const std::string)> toLog)
-        : host(host), user(user), toLog(std::move(toLog))
+        : host(host), user(user), token(token), toLog(std::move(toLog))
     {
 #ifdef IBM
       // Required on Windows
@@ -17,6 +18,11 @@ namespace gaconnector
 #endif
 
       this->webSocket = new ix::WebSocket();
+      this->webSocket->setExtraHeaders({
+          {"origin", "GAClient"},
+          {"authentication", "Bearer " + this->token},
+          {"user", this->user},
+      });
       this->webSocket->enableAutomaticReconnection();
       this->webSocket->setUrl(host);
       this->webSocket->setOnMessageCallback(
@@ -41,44 +47,57 @@ namespace gaconnector
       if (msg->type == ix::WebSocketMessageType::Open) {
         std::stringstream debug_msg;
 
-        debug_msg << std::endl << "New connection" << std::endl;
-        debug_msg << "Uri: " << msg->openInfo.uri << std::endl;
-        debug_msg << "Headers:" << std::endl;
+        debug_msg << "New connection" << std::endl;
+        debug_msg << "\tUri: " << msg->openInfo.uri << std::endl;
+        debug_msg << "\tHeaders:" << std::endl;
         for (const auto &it : msg->openInfo.headers) {
-          debug_msg << it.first << ": " << it.second << std::endl;
+          debug_msg << "\t\t" << it.first << ": " << it.second << std::endl;
         }
-
         this->toLog(debug_msg.str());
 
-        this->webSocket->send("MASTER:" + user);
-        this->toLog("Connecting as " + user);
+        this->toLog("Connected as " + user);
+        this->isLoggedIn = true;
+        this->failureMode = failures::NONE;
       } else if (msg->type == ix::WebSocketMessageType::Close) {
-        if (msg->closeInfo.reason.compare("DUPLICATE") == 0) {
-          this->webSocket->disableAutomaticReconnection();
+        std::stringstream debug_msg;
 
-          this->toLog("Disconnected due to beeing a duplicate simualtor");
-        } else {
-          std::stringstream debug_msg;
+        debug_msg << "Connection closed" << std::endl;
+        debug_msg << "\tCode: " << msg->closeInfo.code << std::endl;
+        debug_msg << "\tReason: " << msg->closeInfo.reason << std::endl;
+        debug_msg << "\tRemote: " << msg->closeInfo.remote << std::endl;
 
-          debug_msg << std::endl << "Connection closed" << std::endl;
-          debug_msg << "Code: " << msg->closeInfo.code << std::endl;
-          debug_msg << "Reason: " << msg->closeInfo.reason << std::endl;
-          debug_msg << "Remote: " << msg->closeInfo.remote << std::endl;
-
-          this->toLog(debug_msg.str());
-        }
+        this->toLog(debug_msg.str());
+        this->isLoggedIn = false;
       } else if (msg->type == ix::WebSocketMessageType::Error) {
         std::stringstream debug_msg;
 
-        debug_msg << std::endl << "Connection error" << std::endl;
-        debug_msg << "Decompression: " << msg->errorInfo.decompressionError
+        debug_msg << "Connection error" << std::endl;
+        debug_msg << "\tDecompression: " << msg->errorInfo.decompressionError
                   << std::endl;
-        debug_msg << "HTTP status: " << msg->errorInfo.http_status << std::endl;
-        debug_msg << "Reason: " << msg->errorInfo.reason << std::endl;
-        debug_msg << "Retries: " << msg->errorInfo.retries << std::endl;
-        debug_msg << "Wait time: " << msg->errorInfo.wait_time << std::endl;
+        debug_msg << "\tHTTP status: " << msg->errorInfo.http_status
+                  << std::endl;
+        debug_msg << "\tReason: " << msg->errorInfo.reason << std::endl;
+        debug_msg << "\tRetries: " << msg->errorInfo.retries << std::endl;
+        debug_msg << "\tWait time: " << msg->errorInfo.wait_time << std::endl;
+
+        if (msg->errorInfo.http_status == 401) {
+          this->webSocket->disableAutomaticReconnection();
+
+          this->toLog("Disabling automatic reconnection due to auth failure");
+          this->failureMode = failures::AUTH;
+        } else if (msg->errorInfo.http_status == 500 &&
+                   msg->errorInfo.reason.find("Duplicate") !=
+                       std::string::npos) {
+          this->webSocket->disableAutomaticReconnection();
+
+          this->toLog("Disabling automatic reconnection due to duplicate");
+          this->failureMode = failures::DUPLICATESIM;
+        } else {
+          this->failureMode = failures::OTHER;
+        }
 
         this->toLog(debug_msg.str());
+        this->isLoggedIn = false;
       } else if (msg->type == ix::WebSocketMessageType::Message) {
         if (!msg->str.empty()) {
           this->toLog(msg->str);
@@ -103,6 +122,7 @@ namespace gaconnector
           {"truHdg", d.truHdg},
           {"totFuel", d.totFuelKg},
           {"fuelFlow", d.ff},
+          {"path", d.path},
           {"hash", this->lastHash},
       };
 

xplugin/CMakeLists.txt

@@ -8,6 +8,7 @@ add_library(germanairlinesva_xplugin SHARED
 )
 
 target_include_directories(germanairlinesva_xplugin PRIVATE
+    ${CMAKE_SOURCE_DIR}/xplugin/include
     ${CMAKE_SOURCE_DIR}/file/include
     ${CMAKE_SOURCE_DIR}/recorder/include
     ${CMAKE_SOURCE_DIR}/simdata/include