GermanAirlines/GermanAirlinesVA-GAConnector
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Namespaces and formatting

Browse Source
This commit is contained in:
Kilian Hofmann 2022-10-03 23:52:38 +02:00
parent 42acea35bb
commit eafe0b18f6
21 changed files with 493 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
esp/include/_simconnect.h
View File

@ -100,7 +100,7 @@ class SimConnect
bool pausedMenu; bool pausedMenu;
bool paused; bool paused;
std::mutex mutex; std::mutex mutex;
struct germanairlinesva::websocket::data simData; struct germanairlinesva::gaconnector::websocket::data simData;
std::shared_ptr<germanairlinesva::file::config::Config> configuration; std::shared_ptr<germanairlinesva::file::config::Config> configuration;
std::function<void(const std::string)> toLog; std::function<void(const std::string)> toLog;
@ -117,7 +117,7 @@ class SimConnect
~SimConnect(); ~SimConnect();
bool isConnected() const; bool isConnected() const;
const std::string getVersion() const; const std::string getVersion() const;
void getData(struct germanairlinesva::websocket::data *data); void getData(struct germanairlinesva::gaconnector::websocket::data *data);
void getStates() const; void getStates() const;
void handleMessage(); void handleMessage();
}; };

2
esp/include/main.h
View File

@ -16,11 +16,11 @@
#include <stdlib.h> #include <stdlib.h>
#include <windows.h> #include <windows.h>
#include "_simconnect.h"
#include "config/config.hpp" #include "config/config.hpp"
#include "constants.h" #include "constants.h"
#include "logbook/logbook.hpp" #include "logbook/logbook.hpp"
#include "recording/recording.hpp" #include "recording/recording.hpp"
#include "_simconnect.h"
#include "simdata/simDatabase.hpp" #include "simdata/simDatabase.hpp"
WINBOOL addNotifyIcon(HWND hWnd); WINBOOL addNotifyIcon(HWND hWnd);

28
esp/main.cpp
View File

@ -12,10 +12,10 @@ std::atomic<bool> wantsExit;
std::shared_ptr<germanairlinesva::file::config::Config> configuration; std::shared_ptr<germanairlinesva::file::config::Config> configuration;
std::unique_ptr<germanairlinesva::file::simdata::SimDatabase> database; std::unique_ptr<germanairlinesva::file::simdata::SimDatabase> database;
std::unique_ptr<germanairlinesva::websocket::Websocket> connector; std::unique_ptr<germanairlinesva::gaconnector::websocket::Websocket> connector;
std::unique_ptr<SimConnect> simConnect; std::unique_ptr<SimConnect> simConnect;
struct germanairlinesva::websocket::data toSend; struct germanairlinesva::gaconnector::websocket::data toSend;
germanairlinesva::file::recording::Recording p; germanairlinesva::file::recording::Recording p;
// The Window Procedure // The Window Procedure
@ -127,10 +127,11 @@ int WINAPI WinMain(HINSTANCE hInstance,
configuration = std::make_unique<germanairlinesva::file::config::Config>(); configuration = std::make_unique<germanairlinesva::file::config::Config>();
toLog("Config loaded"); toLog("Config loaded");
connector = std::make_unique<germanairlinesva::websocket::Websocket>( connector =
"wss://ws.hofmannnet.myhome-server.de:8000", std::make_unique<germanairlinesva::gaconnector::websocket::Websocket>(
configuration->getUser(), "wss://ws.hofmannnet.myhome-server.de:8000",
toLog); configuration->getUser(),
toLog);
toLog("WebSocket started"); toLog("WebSocket started");
#ifndef MSFS #ifndef MSFS
@ -153,7 +154,8 @@ int WINAPI WinMain(HINSTANCE hInstance,
CoTaskMemFree(folder); CoTaskMemFree(folder);
char hash[2 * MD5LEN + 1] = ""; char hash[2 * MD5LEN + 1] = "";
if (germanairlinesva::util::generateMD5(path.c_str(), hash, toLog) == 0) { if (germanairlinesva::utilities::generateMD5(path.c_str(), hash, toLog) ==
0) {
database = std::make_unique<germanairlinesva::file::simdata::SimDatabase>( database = std::make_unique<germanairlinesva::file::simdata::SimDatabase>(
FSX_VERSION, FSX_VERSION,
hash, hash,
@ -324,13 +326,13 @@ void end(HWND hWnd)
void serverWorker() void serverWorker()
{ {
germanairlinesva::util::setThreadName("GAServerWorker"); germanairlinesva::utilities::setThreadName("GAServerWorker");
while (!wantsExit) { while (!wantsExit) {
simConnect->getStates(); simConnect->getStates();
struct germanairlinesva::websocket::data *copy = struct germanairlinesva::gaconnector::websocket::data *copy =
new germanairlinesva::websocket::data(); new germanairlinesva::gaconnector::websocket::data();
{ {
const std::lock_guard<std::mutex> lock(mutex); const std::lock_guard<std::mutex> lock(mutex);
@ -347,7 +349,7 @@ void serverWorker()
void recordingWorker() void recordingWorker()
{ {
germanairlinesva::util::setThreadName("GARecordingWorker"); germanairlinesva::utilities::setThreadName("GARecordingWorker");
germanairlinesva::file::recording::RecordingEntry lastPath; germanairlinesva::file::recording::RecordingEntry lastPath;
std::uint32_t segment = 0; std::uint32_t segment = 0;
@ -356,8 +358,8 @@ void recordingWorker()
auto rwys = ap.second; auto rwys = ap.second;
while (!wantsExit) { while (!wantsExit) {
struct germanairlinesva::websocket::data *copy = struct germanairlinesva::gaconnector::websocket::data *copy =
new germanairlinesva::websocket::data(); new germanairlinesva::gaconnector::websocket::data();
{ {
const std::lock_guard<std::mutex> lock(mutex); const std::lock_guard<std::mutex> lock(mutex);

3
esp/simconnect.cpp
View File

@ -323,7 +323,8 @@ const std::string SimConnect::getVersion() const
} }
} }
void SimConnect::getData(struct germanairlinesva::websocket::data *data) void SimConnect::getData(
struct germanairlinesva::gaconnector::websocket::data *data)
{ {
const std::lock_guard<std::mutex> lock(this->mutex); const std::lock_guard<std::mutex> lock(this->mutex);
memcpy(data, &this->simData, sizeof(this->simData)); memcpy(data, &this->simData, sizeof(this->simData));

6
file/include/config/config.hpp
View File

@ -51,10 +51,10 @@ namespace file
std::ifstream in(BASE_DIRECTORY CONFIG); std::ifstream in(BASE_DIRECTORY CONFIG);
std::string line; std::string line;
while (std::getline(in, line)) { while (std::getline(in, line)) {
std::vector<std::string> fields = util::split(line, '='); std::vector<std::string> fields = utilities::split(line, '=');
if (fields.size() >= 2) { if (fields.size() >= 2) {
util::trim(fields[0]); utilities::trim(fields[0]);
util::trim(fields[1]); utilities::trim(fields[1]);
if (fields[0] == "scenery") { if (fields[0] == "scenery") {
this->scenery = fields[1]; this->scenery = fields[1];
} else if (fields[0] == "user") { } else if (fields[0] == "user") {

2
file/include/logbook/logbook.hpp
View File

@ -117,7 +117,7 @@ namespace file
public: public:
inline Logbook() inline Logbook()
{ {
if (util::fileExists(BASE_DIRECTORY LOGBOOK)) { if (utilities::fileExists(BASE_DIRECTORY LOGBOOK)) {
this->fromFile(); this->fromFile();
} }
} }

8
file/include/recording/recordingEntry.hpp
View File

@ -1,5 +1,5 @@
#ifndef GERMANAIRLINESVA_FILE_RECORDINGENTRY_H #ifndef GERMANAIRLINESVA_FILE_RECORDING_RECORDINGENTRY_H
#define GERMANAIRLINESVA_FILE_RECORDINGENTRY_H #define GERMANAIRLINESVA_FILE_RECORDING_RECORDINGENTRY_H
#include <cstdint> #include <cstdint>
#include <fstream> #include <fstream>
@ -26,14 +26,14 @@ namespace file
std::uint32_t time; std::uint32_t time;
std::uint16_t altitude = 0; std::uint16_t altitude = 0;
std::uint16_t groundSpeed = 0; std::uint16_t groundSpeed = 0;
struct geodata::point coordinates = {NAN, NAN}; struct utilities::geodata::point coordinates = {NAN, NAN};
public: public:
inline RecordingEntry() = default; inline RecordingEntry() = default;
inline RecordingEntry(std::uint32_t time, inline RecordingEntry(std::uint32_t time,
std::uint16_t altitude, std::uint16_t altitude,
std::uint16_t groundSpeed, std::uint16_t groundSpeed,
struct geodata::point coordinates) struct utilities::geodata::point coordinates)
: time(time), altitude(altitude), groundSpeed(groundSpeed), : time(time), altitude(altitude), groundSpeed(groundSpeed),
coordinates(coordinates) coordinates(coordinates)
{ {

8
file/include/simdata/gate.hpp
View File

@ -32,7 +32,7 @@ namespace file
{ {
private: private:
std::string designator; std::string designator;
struct geodata::point center; struct utilities::geodata::point center;
std::uint8_t radius; std::uint8_t radius;
public: public:
@ -45,7 +45,7 @@ namespace file
radius(radius){}; radius(radius){};
// From Database // From Database
inline Gate(std::string designator, inline Gate(std::string designator,
struct geodata::point center, struct utilities::geodata::point center,
std::uint8_t radius) std::uint8_t radius)
: designator(designator), center(center), radius(radius){}; : designator(designator), center(center), radius(radius){};
@ -56,9 +56,9 @@ namespace file
write<decltype(this->radius)>(out, this->radius); write<decltype(this->radius)>(out, this->radius);
} }
inline bool contains(geodata::point coordinates) const inline bool contains(utilities::geodata::point coordinates) const
{ {
return geodata::distanceEarthP(this->center, coordinates); return utilities::geodata::distanceEarthP(this->center, coordinates);
} }
inline const std::string to_string() const inline const std::string to_string() const

52
file/include/simdata/runway.hpp
View File

@ -34,7 +34,7 @@ namespace file
{ {
private: private:
std::string designator; std::string designator;
struct geodata::box bounds; struct utilities::geodata::box bounds;
std::uint8_t width; std::uint8_t width;
std::uint16_t length; std::uint16_t length;
double trueHeading; double trueHeading;
@ -49,52 +49,54 @@ namespace file
double width) double width)
: designator(designator), width(width) : designator(designator), width(width)
{ {
this->length = geodata::distanceEarthD(latitudeStart, this->length = utilities::geodata::distanceEarthD(latitudeStart,
longitudeStart, longitudeStart,
latitudeEnd, latitudeEnd,
longitudeEnd); longitudeEnd);
this->trueHeading = geodata::bearingDD(latitudeStart, this->trueHeading = utilities::geodata::bearingDD(latitudeStart,
longitudeStart, longitudeStart,
latitudeEnd, latitudeEnd,
longitudeEnd); longitudeEnd);
this->bounds = this->bounds = utilities::geodata::calculateBoxDD(
geodata::calculateBoxDD({latitudeStart, longitudeStart}, {latitudeStart, longitudeStart},
{latitudeEnd, longitudeEnd}, {latitudeEnd, longitudeEnd},
this->trueHeading, this->trueHeading,
this->width); this->width);
}; };
// From MakeRwys // From MakeRwys
inline Runway(std::string designator, inline Runway(std::string designator,
struct geodata::point start, struct utilities::geodata::point start,
double width, double width,
double length, double length,
double trueHeading) double trueHeading)
: designator(designator), width(width), length(length), : designator(designator), width(width), length(length),
trueHeading(trueHeading) trueHeading(trueHeading)
{ {
geodata::point end = utilities::geodata::point end =
geodata::calculatePointDD(start, trueHeading, length); utilities::geodata::calculatePointDD(start, trueHeading, length);
this->bounds = this->bounds = utilities::geodata::calculateBoxDD(start,
geodata::calculateBoxDD(start, end, trueHeading, width); end,
trueHeading,
width);
}; };
// From database // From database
inline Runway(std::string designator, inline Runway(std::string designator,
struct geodata::box bounds, struct utilities::geodata::box bounds,
std::uint8_t width, std::uint8_t width,
std::uint16_t length, std::uint16_t length,
double trueHeading) double trueHeading)
: designator(designator), bounds(bounds), width(width), : designator(designator), bounds(bounds), width(width),
length(length), trueHeading(trueHeading){}; length(length), trueHeading(trueHeading){};
inline bool containsPoint(const geodata::point point) const inline bool containsPoint(const utilities::geodata::point point) const
{ {
size_t j = 3; size_t j = 3;
bool c = false; bool c = false;
std::vector<geodata::point> poly{this->bounds.topLeft, std::vector<utilities::geodata::point> poly{this->bounds.topLeft,
this->bounds.topRight, this->bounds.topRight,
this->bounds.bottomRight, this->bounds.bottomRight,
this->bounds.bottomLeft}; this->bounds.bottomLeft};
for (size_t i = 0; i < poly.size(); i++) { for (size_t i = 0; i < poly.size(); i++) {
if ((point.latitude == poly[i].latitude) && if ((point.latitude == poly[i].latitude) &&

10
file/include/simdata/simDatabase.hpp
View File

@ -19,7 +19,7 @@
#ifdef XP #ifdef XP
#include "simdata/simdataXP.hpp" #include "simdata/simdataXP.hpp"
#endif #endif
#ifndef MSFS #if not defined(XP) && not defined(MSFS)
#include "simdata/simdataESP.hpp" #include "simdata/simdataESP.hpp"
#endif #endif
@ -61,7 +61,8 @@ namespace file
std::uint16_t numGates = read<std::uint16_t>(in); std::uint16_t numGates = read<std::uint16_t>(in);
for (int j = 0; j < numGates; j++) { for (int j = 0; j < numGates; j++) {
std::string designator = readString(in); std::string designator = readString(in);
struct geodata::point center = read<struct geodata::point>(in); struct utilities::geodata::point center =
read<struct utilities::geodata::point>(in);
std::uint8_t radius = read<std::uint8_t>(in); std::uint8_t radius = read<std::uint8_t>(in);
this->airports[icao].first.emplace_back(designator, this->airports[icao].first.emplace_back(designator,
@ -73,7 +74,8 @@ namespace file
for (int j = 0; j < numRunways; j++) { for (int j = 0; j < numRunways; j++) {
std::string designator = readString(in); std::string designator = readString(in);
// Center // Center
struct geodata::box bounds = read<struct geodata::box>(in); struct utilities::geodata::box bounds =
read<struct utilities::geodata::box>(in);
std::uint8_t width = read<std::uint8_t>(in); std::uint8_t width = read<std::uint8_t>(in);
std::uint16_t length = read<std::uint16_t>(in); std::uint16_t length = read<std::uint16_t>(in);
double trueHeading = read<double>(in); double trueHeading = read<double>(in);
@ -113,7 +115,7 @@ namespace file
std::function<void(const std::string)> toLog) std::function<void(const std::string)> toLog)
{ {
if (strcmp(configuration->getScenery().c_str(), hash) != 0 || if (strcmp(configuration->getScenery().c_str(), hash) != 0 ||
!util::fileExists(BASE_DIRECTORY SIMDATABASE)) { !utilities::fileExists(BASE_DIRECTORY SIMDATABASE)) {
#ifdef XP #ifdef XP
scan(simVersion < 12000 ? XPLANE11_BASE_SCENERY scan(simVersion < 12000 ? XPLANE11_BASE_SCENERY
: XPLANE12_BASE_SCENERY, : XPLANE12_BASE_SCENERY,

23
file/include/simdata/simdataESP.hpp
View File

@ -1,5 +1,5 @@
#ifndef GERMANAIRLINESVA_FILE_SIMDATA_SIMDATAXP_H #ifndef GERMANAIRLINESVA_FILE_SIMDATA_SIMDATAESP_H
#define GERMANAIRLINESVA_FILE_SIMDATA_SIMDATAXP_H #define GERMANAIRLINESVA_FILE_SIMDATA_SIMDATAESP_H
#include <cstdint> #include <cstdint>
#include <fstream> #include <fstream>
@ -55,7 +55,7 @@ namespace file
log << "<FILE> " << runwaysFile << std::endl; log << "<FILE> " << runwaysFile << std::endl;
while (std::getline(runways, line)) { while (std::getline(runways, line)) {
std::vector<std::string> fields = util::split(line, ','); std::vector<std::string> fields = utilities::split(line, ',');
// New ICAO // New ICAO
if (currentIcao != nullptr && *currentIcao != fields[0]) { if (currentIcao != nullptr && *currentIcao != fields[0]) {
tmpAirportRunways[*currentIcao] = tmpRunways; tmpAirportRunways[*currentIcao] = tmpRunways;
@ -85,20 +85,21 @@ namespace file
designator = "0" + designator; designator = "0" + designator;
} }
struct geodata::point start = {std::stod(fields[2]), struct utilities::geodata::point start = {std::stod(fields[2]),
std::stod(fields[3])}; std::stod(fields[3])};
tmpRunways.emplace_back(designator, tmpRunways.emplace_back(
start, designator,
geodata::toMetre(std::stod(fields[8])), start,
geodata::toMetre(std::stod(fields[6])), utilities::geodata::toMetre(std::stod(fields[8])),
std::stod(fields[5]) + std::stod(fields[9])); utilities::geodata::toMetre(std::stod(fields[6])),
std::stod(fields[5]) + std::stod(fields[9]));
log << "\t<RUNWAY> " << line << std::endl; log << "\t<RUNWAY> " << line << std::endl;
} }
currentIcao = nullptr; currentIcao = nullptr;
while (std::getline(gates, line)) { while (std::getline(gates, line)) {
std::vector<std::string> fields = util::split(line, ','); std::vector<std::string> fields = utilities::split(line, ',');
// New ICAO // New ICAO
if (currentIcao != nullptr && *currentIcao != fields[0]) { if (currentIcao != nullptr && *currentIcao != fields[0]) {
tmpAirportGates[*currentIcao] = tmpGates; tmpAirportGates[*currentIcao] = tmpGates;

11
file/include/simdata/simdataXP.hpp
View File

@ -79,10 +79,11 @@ namespace file
int validCount = 0; int validCount = 0;
while (std::getline(infile, line)) { while (std::getline(infile, line)) {
std::vector<std::string> fields = util::split(line, ' '); std::vector<std::string> fields = utilities::split(line, ' ');
fields = util::select_T<std::string>(fields, [](const std::string &s) { fields =
return s.length() > 0; utilities::select_T<std::string>(fields, [](const std::string &s) {
}); return s.length() > 0;
});
if (fields.empty()) if (fields.empty())
continue; continue;
@ -173,7 +174,7 @@ namespace file
std::vector<std::string> packs; std::vector<std::string> packs;
while (std::getline(custom, line)) { while (std::getline(custom, line)) {
if ((pos = line.find("SCENERY_PACK")) != std::string::npos) { if ((pos = line.find("SCENERY_PACK")) != std::string::npos) {
std::string path = util::rtrim_copy(line.substr(pos + 13)) + std::string path = utilities::rtrim_copy(line.substr(pos + 13)) +
"Earth nav data/apt.dat"; "Earth nav data/apt.dat";
packs.emplace_back(path); packs.emplace_back(path);
} }

2
format.sh
View File

@ -2,7 +2,7 @@
shopt -s globstar shopt -s globstar
GLOBIGNORE='**/XPLM/**:XPLM/**:**/XPLM:**/ixwebsocket/**:ixwebsocket/**:**/ixwebsocket:**/nlohmann/**:nlohmann/**:**/nlohmann:**/XPSDK/**:XPSDK/**:**/XPSDK:**/build*/**:build*/**:**/build*:**/openSSL/**:openSSL/**:**/openSSL' GLOBIGNORE='**/XPLM/**:XPLM/**:**/XPLM:**/ixwebsocket/**:ixwebsocket/**:**/ixwebsocket:**/nlohmann/**:nlohmann/**:**/nlohmann:**/XPSDK/**:XPSDK/**:**/XPSDK:**/build*/**:build*/**:**/build*:**/openSSL/**:openSSL/**:**/openSSL:**/SimConnect/**:SimConnect/**:**/SimConnect'
clang-format -verbose -i **/*.cpp clang-format -verbose -i **/*.cpp
clang-format -verbose -i **/*.h clang-format -verbose -i **/*.h

17
recorder/include/recorder.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef GERMANAIRLINESVA_GACONNECTOR_RECORDER_RECORDER_H
#define GERMANAIRLINESVA_GACONNECTOR_RECORDER_RECORDER_H
namespace germanairlinesva
{
namespace gaconnector
{
namespace recorder
{
class Recorder
{
};
} // namespace recorder
} // namespace gaconnector
} // namespace germanairlinesva
#endif

4
utilities/include/constants.h
View File

@ -1,5 +1,5 @@
#ifndef GERMANAIRLINESVA_GACONNECTOR_CONSTANTS_H #ifndef GERMANAIRLINESVA_UTILITIES_CONSTANTS_H
#define GERMANAIRLINESVA_GACONNECTOR_CONSTANTS_H #define GERMANAIRLINESVA_UTILITIES_CONSTANTS_H
#ifdef XP #ifdef XP
#define BASE_DIRECTORY "Resources/plugins/GAConnector/" #define BASE_DIRECTORY "Resources/plugins/GAConnector/"

397
utilities/include/geodata.hpp
View File

@ -1,5 +1,5 @@
#ifndef GERMANAIRLINESVA_GACONNECTOR_GEODATA_H #ifndef GERMANAIRLINESVA_UTILITIES_GEODATA_H
#define GERMANAIRLINESVA_GACONNECTOR_GEODATA_H #define GERMANAIRLINESVA_UTILITIES_GEODATA_H
#define M_PI 3.14159265358979323846 #define M_PI 3.14159265358979323846
#define BUFSIZE 1024 #define BUFSIZE 1024
@ -10,235 +10,242 @@
namespace germanairlinesva namespace germanairlinesva
{ {
namespace geodata namespace utilities
{ {
namespace geodata
{
#pragma pack(push) #pragma pack(push)
#pragma pack(1) #pragma pack(1)
struct point { struct point {
double latitude; double latitude;
double longitude; double longitude;
}; };
#pragma pack(pop) #pragma pack(pop)
#pragma pack(push) #pragma pack(push)
#pragma pack(1) #pragma pack(1)
struct box { struct box {
struct point topLeft; struct point topLeft;
struct point topRight; struct point topRight;
struct point bottomRight; struct point bottomRight;
struct point bottomLeft; struct point bottomLeft;
}; };
#pragma pack(pop) #pragma pack(pop)
static inline double toMetre(double value) { return value * 0.3048; } static inline double toMetre(double value) { return value * 0.3048; }
static inline double toFeet(double value) { return value * 3.280839895; } static inline double toFeet(double value) { return value * 3.280839895; }
static inline double toDegrees(double value) { return value * 180 / M_PI; } static inline double toDegrees(double value) { return value * 180 / M_PI; }
static inline double toRadians(double value) { return value * M_PI / 180; } static inline double toRadians(double value) { return value * M_PI / 180; }
static inline double normalizeD(double value) static inline double normalizeD(double value)
{ {
return fmod(value + 360, 360); return fmod(value + 360, 360);
} }
static inline double normalizeR(double value) static inline double normalizeR(double value)
{ {
return value < 0 ? 2 * M_PI + value : value; return value < 0 ? 2 * M_PI + value : value;
} }
// Input and Output in degrees // Input and Output in degrees
static inline double bearingDD(double fromLatitude, static inline double bearingDD(double fromLatitude,
double fromLongitude, double fromLongitude,
double toLatitude, double toLatitude,
double toLongitude) double toLongitude)
{ {
double y = sin(toRadians(toLongitude) - toRadians(fromLongitude)) * double y = sin(toRadians(toLongitude) - toRadians(fromLongitude)) *
cos(toRadians(toLatitude)); cos(toRadians(toLatitude));
double x = cos(toRadians(fromLatitude)) * sin(toRadians(toLatitude)) - double x = cos(toRadians(fromLatitude)) * sin(toRadians(toLatitude)) -
sin(toRadians(fromLatitude)) * cos(toRadians(toLatitude)) * sin(toRadians(fromLatitude)) * cos(toRadians(toLatitude)) *
cos(toRadians(toLongitude) - toRadians(fromLongitude)); cos(toRadians(toLongitude) - toRadians(fromLongitude));
return normalizeD(toDegrees(atan2(y, x))); return normalizeD(toDegrees(atan2(y, x)));
} }
// Input in degrees, Output in radians // Input in degrees, Output in radians
static inline double bearingDR(double fromLatitude, static inline double bearingDR(double fromLatitude,
double fromLongitude, double fromLongitude,
double toLatitude, double toLatitude,
double toLongitude) double toLongitude)
{ {
double y = sin(toRadians(toLongitude) - toRadians(fromLongitude)) * double y = sin(toRadians(toLongitude) - toRadians(fromLongitude)) *
cos(toRadians(toLatitude)); cos(toRadians(toLatitude));
double x = cos(toRadians(fromLatitude)) * sin(toRadians(toLatitude)) - double x = cos(toRadians(fromLatitude)) * sin(toRadians(toLatitude)) -
sin(toRadians(fromLatitude)) * cos(toRadians(toLatitude)) * sin(toRadians(fromLatitude)) * cos(toRadians(toLatitude)) *
cos(toRadians(toLongitude) - toRadians(fromLongitude)); cos(toRadians(toLongitude) - toRadians(fromLongitude));
return normalizeR(atan2(y, x)); return normalizeR(atan2(y, x));
} }
// Input in degrees, Output in metres // Input in degrees, Output in metres
static inline double distanceEarthD(double fromLatitude, static inline double distanceEarthD(double fromLatitude,
double fromLongitude, double fromLongitude,
double toLatitude, double toLatitude,
double toLongitude) double toLongitude)
{ {
double lat1r, lon1r, lat2r, lon2r, u, v; double lat1r, lon1r, lat2r, lon2r, u, v;
lat1r = toRadians(fromLatitude); lat1r = toRadians(fromLatitude);
lon1r = toRadians(fromLongitude); lon1r = toRadians(fromLongitude);
lat2r = toRadians(toLatitude); lat2r = toRadians(toLatitude);
lon2r = toRadians(toLongitude); lon2r = toRadians(toLongitude);
u = sin((lat2r - lat1r) / 2); u = sin((lat2r - lat1r) / 2);
v = sin((lon2r - lon1r) / 2); v = sin((lon2r - lon1r) / 2);
return 2.0 * EARTH_M * asin(sqrt(u * u + cos(lat1r) * cos(lat2r) * v * v)); return 2.0 * EARTH_M *
} asin(sqrt(u * u + cos(lat1r) * cos(lat2r) * v * v));
}
// Input in degrees, Output in metres // Input in degrees, Output in metres
static inline double distanceEarthP(point from, point to) static inline double distanceEarthP(point from, point to)
{ {
double lat1r, lon1r, lat2r, lon2r, u, v; double lat1r, lon1r, lat2r, lon2r, u, v;
lat1r = toRadians(from.latitude); lat1r = toRadians(from.latitude);
lon1r = toRadians(from.longitude); lon1r = toRadians(from.longitude);
lat2r = toRadians(to.latitude); lat2r = toRadians(to.latitude);
lon2r = toRadians(to.longitude); lon2r = toRadians(to.longitude);
u = sin((lat2r - lat1r) / 2); u = sin((lat2r - lat1r) / 2);
v = sin((lon2r - lon1r) / 2); v = sin((lon2r - lon1r) / 2);
return 2.0 * EARTH_M * asin(sqrt(u * u + cos(lat1r) * cos(lat2r) * v * v)); return 2.0 * EARTH_M *
} asin(sqrt(u * u + cos(lat1r) * cos(lat2r) * v * v));
}
// Input and Output in degrees // Input and Output in degrees
static inline struct point calculatePointDD(struct point coordinates, static inline struct point calculatePointDD(struct point coordinates,
double bearing, double bearing,
double distance) double distance)
{ {
double r_latitude = toRadians(coordinates.latitude); double r_latitude = toRadians(coordinates.latitude);
double r_longitude = toRadians(coordinates.longitude); double r_longitude = toRadians(coordinates.longitude);
double r_bearing = toRadians(bearing); double r_bearing = toRadians(bearing);
double newLatitude = double newLatitude =
std::asin(std::sin(r_latitude) * std::cos(distance / EARTH_M) + std::asin(std::sin(r_latitude) * std::cos(distance / EARTH_M) +
std::cos(r_latitude) * std::sin(distance / EARTH_M) * std::cos(r_latitude) * std::sin(distance / EARTH_M) *
std::cos(r_bearing)); std::cos(r_bearing));
double newLongitude = double newLongitude =
r_longitude + r_longitude +
std::atan2(std::sin(r_bearing) * std::sin(distance / EARTH_M) * std::atan2(std::sin(r_bearing) * std::sin(distance / EARTH_M) *
std::cos(r_latitude), std::cos(r_latitude),
std::cos(distance / EARTH_M) - std::cos(distance / EARTH_M) -
std::sin(r_latitude) * std::sin(newLatitude)); std::sin(r_latitude) * std::sin(newLatitude));
return {toDegrees(newLatitude), toDegrees(newLongitude)}; return {toDegrees(newLatitude), toDegrees(newLongitude)};
} }
// Input in degrees, Output in radians // Input in degrees, Output in radians
static inline struct point calculatePointDR(struct point coordinates, static inline struct point calculatePointDR(struct point coordinates,
double bearing, double bearing,
double distance) double distance)
{ {
double r_latitude = toRadians(coordinates.latitude); double r_latitude = toRadians(coordinates.latitude);
double r_longitude = toRadians(coordinates.longitude); double r_longitude = toRadians(coordinates.longitude);
double r_bearing = toRadians(bearing); double r_bearing = toRadians(bearing);
double newLatitude = double newLatitude =
std::asin(std::sin(r_latitude) * std::cos(distance / EARTH_M) + std::asin(std::sin(r_latitude) * std::cos(distance / EARTH_M) +
std::cos(r_latitude) * std::sin(distance / EARTH_M) * std::cos(r_latitude) * std::sin(distance / EARTH_M) *
std::cos(r_bearing)); std::cos(r_bearing));
double newLongitude = double newLongitude =
r_longitude + r_longitude +
std::atan2(std::sin(r_bearing) * std::sin(distance / EARTH_M) * std::atan2(std::sin(r_bearing) * std::sin(distance / EARTH_M) *
std::cos(r_latitude), std::cos(r_latitude),
std::cos(distance / EARTH_M) - std::cos(distance / EARTH_M) -
std::sin(r_latitude) * std::sin(newLatitude)); std::sin(r_latitude) * std::sin(newLatitude));
return {newLatitude, newLongitude}; return {newLatitude, newLongitude};
} }
// LAT/LON in radians, BEARING/Output in degrees // LAT/LON in radians, BEARING/Output in degrees
static inline struct point calculatePointRD(struct point coordinates, static inline struct point calculatePointRD(struct point coordinates,
double bearing, double bearing,
double distance) double distance)
{ {
double r_bearing = toRadians(bearing); double r_bearing = toRadians(bearing);
double newLatitude = std::asin( double newLatitude = std::asin(
std::sin(coordinates.latitude) * std::cos(distance / EARTH_M) + std::sin(coordinates.latitude) * std::cos(distance / EARTH_M) +
std::cos(coordinates.latitude) * std::sin(distance / EARTH_M) * std::cos(coordinates.latitude) * std::sin(distance / EARTH_M) *
std::cos(r_bearing)); std::cos(r_bearing));
double newLongitude = double newLongitude =
coordinates.longitude + coordinates.longitude +
std::atan2(std::sin(r_bearing) * std::sin(distance / EARTH_M) * std::atan2(std::sin(r_bearing) * std::sin(distance / EARTH_M) *
std::cos(coordinates.latitude), std::cos(coordinates.latitude),
std::cos(distance / EARTH_M) - std::cos(distance / EARTH_M) -
std::sin(coordinates.latitude) * std::sin(newLatitude)); std::sin(coordinates.latitude) *
std::sin(newLatitude));
return {toDegrees(newLatitude), toDegrees(newLongitude)}; return {toDegrees(newLatitude), toDegrees(newLongitude)};
} }
// LAT/LON/Output in radians, BEARING in degrees // LAT/LON/Output in radians, BEARING in degrees
static inline struct point calculatePointRR(struct point coordinates, static inline struct point calculatePointRR(struct point coordinates,
double bearing, double bearing,
double distance) double distance)
{ {
double r_bearing = toRadians(bearing); double r_bearing = toRadians(bearing);
double newLatitude = std::asin( double newLatitude = std::asin(
std::sin(coordinates.latitude) * std::cos(distance / EARTH_M) + std::sin(coordinates.latitude) * std::cos(distance / EARTH_M) +
std::cos(coordinates.latitude) * std::sin(distance / EARTH_M) * std::cos(coordinates.latitude) * std::sin(distance / EARTH_M) *
std::cos(r_bearing)); std::cos(r_bearing));
double newLongitude = double newLongitude =
coordinates.longitude + coordinates.longitude +
std::atan2(std::sin(r_bearing) * std::sin(distance / EARTH_M) * std::atan2(std::sin(r_bearing) * std::sin(distance / EARTH_M) *
std::cos(coordinates.latitude), std::cos(coordinates.latitude),
std::cos(distance / EARTH_M) - std::cos(distance / EARTH_M) -
std::sin(coordinates.latitude) * std::sin(newLatitude)); std::sin(coordinates.latitude) *
std::sin(newLatitude));
return {newLatitude, newLongitude}; return {newLatitude, newLongitude};
} }
// Input in degrees, calculate from center // Input in degrees, calculate from center
static inline box calculateBoxDD(struct point center, static inline box calculateBoxDD(struct point center,
double bearing, double bearing,
double length, double length,
double width) double width)
{ {
struct point primaryCenter = calculatePointDR(center, bearing, -length / 2); struct point primaryCenter =
struct point secondaryCenter = calculatePointDR(center, bearing, -length / 2);
calculatePointDR(center, bearing, length / 2); struct point secondaryCenter =
double offsetHeadingNorth = calculatePointDR(center, bearing, length / 2);
bearing - 90 > 0 ? bearing - 90 : bearing - 90 + 360; double offsetHeadingNorth =
struct point primaryTop = bearing - 90 > 0 ? bearing - 90 : bearing - 90 + 360;
calculatePointRD(primaryCenter, offsetHeadingNorth, width / 2); struct point primaryTop =
struct point primaryBottom = calculatePointRD(primaryCenter, offsetHeadingNorth, width / 2);
calculatePointRD(primaryCenter, offsetHeadingNorth, -width / 2); struct point primaryBottom =
struct point secondaryTop = calculatePointRD(primaryCenter, offsetHeadingNorth, -width / 2);
calculatePointRD(secondaryCenter, offsetHeadingNorth, width / 2); struct point secondaryTop =
struct point secondaryBottom = calculatePointRD(secondaryCenter, offsetHeadingNorth, width / 2);
calculatePointRD(secondaryCenter, offsetHeadingNorth, -width / 2); struct point secondaryBottom =
calculatePointRD(secondaryCenter, offsetHeadingNorth, -width / 2);
return {primaryTop, secondaryTop, secondaryBottom, primaryBottom}; return {primaryTop, secondaryTop, secondaryBottom, primaryBottom};
} }
// Input in degrees, calculate from start end // Input in degrees, calculate from start end
static inline box calculateBoxDD(struct point start, static inline box calculateBoxDD(struct point start,
struct point end, struct point end,
double bearing, double bearing,
double width) double width)
{ {
double offsetHeadingNorth = double offsetHeadingNorth =
bearing - 90 > 0 ? bearing - 90 : bearing - 90 + 360; bearing - 90 > 0 ? bearing - 90 : bearing - 90 + 360;
struct point primaryTop = struct point primaryTop =
calculatePointDD(start, offsetHeadingNorth, width / 2); calculatePointDD(start, offsetHeadingNorth, width / 2);
struct point primaryBottom = struct point primaryBottom =
calculatePointDD(start, offsetHeadingNorth, -width / 2); calculatePointDD(start, offsetHeadingNorth, -width / 2);
struct point secondaryTop = struct point secondaryTop =
calculatePointDD(end, offsetHeadingNorth, width / 2); calculatePointDD(end, offsetHeadingNorth, width / 2);
struct point secondaryBottom = struct point secondaryBottom =
calculatePointDD(end, offsetHeadingNorth, -width / 2); calculatePointDD(end, offsetHeadingNorth, -width / 2);
return {primaryTop, secondaryTop, secondaryBottom, primaryBottom}; return {primaryTop, secondaryTop, secondaryBottom, primaryBottom};
} }
} // namespace geodata
} // namespace geodata } // namespace utilities
} // namespace germanairlinesva } // namespace germanairlinesva
#endif #endif

8
utilities/include/util.hpp
View File

@ -1,5 +1,5 @@
#ifndef GERMANAIRLINESVA_GACONNECTOR_UTIL_H #ifndef GERMANAIRLINESVA_UTILITIES_UTIL_H
#define GERMANAIRLINESVA_GACONNECTOR_UTIL_H #define GERMANAIRLINESVA_UTILITIES_UTIL_H
#define BUFSIZE 1024 #define BUFSIZE 1024
#define MD5LEN 16 #define MD5LEN 16
@ -36,7 +36,7 @@
namespace germanairlinesva namespace germanairlinesva
{ {
namespace util namespace utilities
{ {
template <typename T> template <typename T>
static inline std::vector<T> static inline std::vector<T>
@ -294,7 +294,7 @@ namespace util
return result; return result;
} }
} // namespace util } // namespace utilities
} // namespace germanairlinesva } // namespace germanairlinesva
#endif #endif

81
websocket/include/types.h
View File

@ -1,51 +1,64 @@
#ifndef GERMANAIRLINESVA_GACONNECTOR_SOCKET_TYPES_H #ifndef GERMANAIRLINESVA_GACONNECTOR_WEBSOCKET_TYPES_H
#define GERMANAIRLINESVA_GACONNECTOR_SOCKET_TYPES_H #define GERMANAIRLINESVA_GACONNECTOR_WEBSOCKET_TYPES_H
#include <cstdint> #include <cstdint>
namespace germanairlinesva namespace germanairlinesva
{ {
namespace websocket namespace gaconnector
{ {
namespace websocket
{
#pragma pack(push) /* push current alignment to stack */ #pragma pack(push) /* push current alignment to stack */
#pragma pack(1) /* set alignment to 1 byte boundary */ #pragma pack(1) /* set alignment to 1 byte boundary */
/* Structures and enums */ /* Structures and enums */
struct data { struct data {
std::int32_t pause = 0; std::int32_t pause = 0;
float pBrake = 0; float pBrake = 0;
std::int32_t onGrnd = 0; std::int32_t onGrnd = 0;
float totFuelKg = 0; float totFuelKg = 0;
float truHdg = 0; float truHdg = 0;
double alt = 0; double alt = 0;
float gs = 0; float gs = 0;
float ias = 0; float ias = 0;
float vs = 0; float vs = 0;
double lat = 0; double lat = 0;
double lon = 0; double lon = 0;
float ff[8] = {0, 0, 0, 0, 0, 0, 0, 0}; float ff[8] = {0, 0, 0, 0, 0, 0, 0, 0};
float maxSpd = 0; float maxSpd = 0;
char path[513] = ""; char path[513] = "";
float uptime = 0; float uptime = 0;
float magHeading = 0; float magHeading = 0;
float payloadKg = 0; float payloadKg = 0;
float totalWeightKg = 0; float totalWeightKg = 0;
}; };
enum commands { PROCESS, SAVE, LOAD, TEXT, TIME, UNPAUSE, PAUSE, PORT, END }; enum commands {
PROCESS,
SAVE,
LOAD,
TEXT,
TIME,
UNPAUSE,
PAUSE,
PORT,
END
};
struct command_base { struct command_base {
enum commands type; enum commands type;
}; };
struct command_port { struct command_port {
double latitude; double latitude;
double longitude; double longitude;
float trueHeading; float trueHeading;
}; };
#pragma pack(pop) /* restore original alignment from stack */ #pragma pack(pop) /* restore original alignment from stack */
} // namespace websocket } // namespace websocket
} // namespace gaconnector
} // namespace germanairlinesva } // namespace germanairlinesva
#endif #endif

43
websocket/include/websocket.h
View File

@ -1,5 +1,5 @@
#ifndef GERMANAIRLINESVA_GACONNECTOR_WEBSOCKET_H #ifndef GERMANAIRLINESVA_GACONNECTOR_WEBSOCKET_WEBSOCKET_H
#define GERMANAIRLINESVA_GACONNECTOR_WEBSOCKET_H #define GERMANAIRLINESVA_GACONNECTOR_WEBSOCKET_WEBSOCKET_H
#define BUFSIZE 1024 #define BUFSIZE 1024
#define MD5LEN 16 #define MD5LEN 16
@ -20,27 +20,30 @@
namespace germanairlinesva namespace germanairlinesva
{ {
namespace websocket namespace gaconnector
{ {
class Websocket namespace websocket
{ {
private: class Websocket
char lastPath[513] = ""; {
char lastHash[2 * MD5LEN + 1] = ""; private:
ix::WebSocket *webSocket = nullptr; char lastPath[513] = "";
std::string host; char lastHash[2 * MD5LEN + 1] = "";
std::string user; ix::WebSocket *webSocket = nullptr;
std::function<void(const std::string)> toLog; std::string host;
std::string user;
std::function<void(const std::string)> toLog;
public: public:
Websocket(std::string host, Websocket(std::string host,
std::string user, std::string user,
std::function<void(const std::string)> toLog); std::function<void(const std::string)> toLog);
~Websocket(); ~Websocket();
void onClientMessageCallback(const ix::WebSocketMessagePtr &msg); void onClientMessageCallback(const ix::WebSocketMessagePtr &msg);
void sendData(data &d); void sendData(data &d);
}; };
} // namespace websocket } // namespace websocket
} // namespace gaconnector
} // namespace germanairlinesva } // namespace germanairlinesva
#endif #endif

179
websocket/websocket.cpp
View File

@ -2,113 +2,116 @@
namespace germanairlinesva namespace germanairlinesva
{ {
namespace websocket namespace gaconnector
{ {
Websocket::Websocket(std::string host, namespace websocket
std::string user,
std::function<void(const std::string)> toLog)
: host(host), user(user), toLog(std::move(toLog))
{ {
Websocket::Websocket(std::string host,
std::string user,
std::function<void(const std::string)> toLog)
: host(host), user(user), toLog(std::move(toLog))
{
#ifdef IBM #ifdef IBM
// Required on Windows // Required on Windows
ix::initNetSystem(); ix::initNetSystem();
#endif #endif
this->webSocket = new ix::WebSocket(); this->webSocket = new ix::WebSocket();
this->webSocket->enableAutomaticReconnection(); this->webSocket->enableAutomaticReconnection();
this->webSocket->setUrl(host); this->webSocket->setUrl(host);
this->webSocket->setOnMessageCallback( this->webSocket->setOnMessageCallback(
[this](const ix::WebSocketMessagePtr &msg) { [this](const ix::WebSocketMessagePtr &msg) {
this->onClientMessageCallback(msg); this->onClientMessageCallback(msg);
}); });
this->webSocket->start(); this->webSocket->start();
} }
Websocket::~Websocket() Websocket::~Websocket()
{ {
this->webSocket->stop(); this->webSocket->stop();
this->toLog("WebSocket stopped"); this->toLog("WebSocket stopped");
#ifdef IBM #ifdef IBM
// Required on Windows // Required on Windows
ix::uninitNetSystem(); ix::uninitNetSystem();
#endif #endif
} }
void Websocket::onClientMessageCallback(const ix::WebSocketMessagePtr &msg) void Websocket::onClientMessageCallback(const ix::WebSocketMessagePtr &msg)
{ {
if (msg->type == ix::WebSocketMessageType::Open) { 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;
for (const auto &it : msg->openInfo.headers) {
debug_msg << it.first << ": " << it.second << std::endl;
}
this->toLog(debug_msg.str());
this->webSocket->send("MASTER:" + user);
this->toLog("Connecting as " + user);
} else if (msg->type == ix::WebSocketMessageType::Close) {
if (msg->closeInfo.reason.compare("DUPLICATE") == 0) {
this->webSocket->disableAutomaticReconnection();
this->toLog("Disconnected due to beeing a duplicate simualtor");
} else {
std::stringstream debug_msg; std::stringstream debug_msg;
debug_msg << std::endl << "Connection closed" << std::endl; debug_msg << std::endl << "New connection" << std::endl;
debug_msg << "Code: " << msg->closeInfo.code << std::endl; debug_msg << "Uri: " << msg->openInfo.uri << std::endl;
debug_msg << "Reason: " << msg->closeInfo.reason << std::endl; debug_msg << "Headers:" << std::endl;
debug_msg << "Remote: " << msg->closeInfo.remote << std::endl; for (const auto &it : msg->openInfo.headers) {
debug_msg << it.first << ": " << it.second << std::endl;
}
this->toLog(debug_msg.str()); this->toLog(debug_msg.str());
}
} else if (msg->type == ix::WebSocketMessageType::Error) {
std::stringstream debug_msg;
debug_msg << std::endl << "Connection error" << std::endl; this->webSocket->send("MASTER:" + user);
debug_msg << "Decompression: " << msg->errorInfo.decompressionError this->toLog("Connecting as " + user);
<< std::endl; } else if (msg->type == ix::WebSocketMessageType::Close) {
debug_msg << "HTTP status: " << msg->errorInfo.http_status << std::endl; if (msg->closeInfo.reason.compare("DUPLICATE") == 0) {
debug_msg << "Reason: " << msg->errorInfo.reason << std::endl; this->webSocket->disableAutomaticReconnection();
debug_msg << "Retries: " << msg->errorInfo.retries << std::endl;
debug_msg << "Wait time: " << msg->errorInfo.wait_time << std::endl;
this->toLog(debug_msg.str()); this->toLog("Disconnected due to beeing a duplicate simualtor");
} else if (msg->type == ix::WebSocketMessageType::Message) { } else {
if (!msg->str.empty()) { std::stringstream debug_msg;
this->toLog(msg->str);
}
}
}
void Websocket::sendData(data &d) debug_msg << std::endl << "Connection closed" << std::endl;
{ debug_msg << "Code: " << msg->closeInfo.code << std::endl;
if (strcmp(d.path, this->lastPath) != 0) { debug_msg << "Reason: " << msg->closeInfo.reason << std::endl;
strcpy(this->lastPath, d.path); debug_msg << "Remote: " << msg->closeInfo.remote << std::endl;
if (util::generateMD5(d.path, this->lastHash, this->toLog)) {
strcpy(this->lastHash, "NOT SET"); this->toLog(debug_msg.str());
}
} 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
<< 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;
this->toLog(debug_msg.str());
} else if (msg->type == ix::WebSocketMessageType::Message) {
if (!msg->str.empty()) {
this->toLog(msg->str);
}
} }
} }
nlohmann::json json = { void Websocket::sendData(data &d)
{"altitude", d.alt}, {
{"vs", d.vs}, if (strcmp(d.path, this->lastPath) != 0) {
{"ias", d.ias}, strcpy(this->lastPath, d.path);
{"magHdg", d.magHeading}, if (utilities::generateMD5(d.path, this->lastHash, this->toLog)) {
{"truHdg", d.truHdg}, strcpy(this->lastHash, "NOT SET");
{"totFuel", d.totFuelKg}, }
{"fuelFlow", d.ff}, }
{"hash", this->lastHash},
};
if (this->webSocket != nullptr) { nlohmann::json json = {
std::ostringstream msg; {"altitude", d.alt},
msg << "SEND:" << user << ":" << json.dump(); {"vs", d.vs},
this->webSocket->send(msg.str(), false); {"ias", d.ias},
{"magHdg", d.magHeading},
{"truHdg", d.truHdg},
{"totFuel", d.totFuelKg},
{"fuelFlow", d.ff},
{"hash", this->lastHash},
};
if (this->webSocket != nullptr) {
std::ostringstream msg;
msg << "SEND:" << user << ":" << json.dump();
this->webSocket->send(msg.str(), false);
}
} }
} } // namespace websocket
} // namespace websocket } // namespace gaconnector
} // namespace germanairlinesva } // namespace germanairlinesva

38
xplugin/main.cpp
View File

@ -12,7 +12,7 @@ std::atomic<bool> wantsExit;
std::shared_ptr<germanairlinesva::file::config::Config> configuration; std::shared_ptr<germanairlinesva::file::config::Config> configuration;
std::unique_ptr<germanairlinesva::file::simdata::SimDatabase> database; std::unique_ptr<germanairlinesva::file::simdata::SimDatabase> database;
std::unique_ptr<germanairlinesva::websocket::Websocket> connector; std::unique_ptr<germanairlinesva::gaconnector::websocket::Websocket> connector;
int xplaneVersion; int xplaneVersion;
/* Datarefs */ /* Datarefs */
@ -43,7 +43,7 @@ XPLMDataRef pitch;
XPLMDataRef roll; XPLMDataRef roll;
XPLMDataRef quaternion; XPLMDataRef quaternion;
struct germanairlinesva::websocket::data toSend; struct germanairlinesva::gaconnector::websocket::data toSend;
germanairlinesva::file::recording::Recording p; germanairlinesva::file::recording::Recording p;
/* /*
@ -114,15 +114,17 @@ PLUGIN_API int XPluginStart(char *outName, char *outSig, char *outDesc)
configuration = std::make_unique<germanairlinesva::file::config::Config>(); configuration = std::make_unique<germanairlinesva::file::config::Config>();
toLog("Config loaded"); toLog("Config loaded");
connector = std::make_unique<germanairlinesva::websocket::Websocket>( connector =
"wss://ws.hofmannnet.myhome-server.de:8000", std::make_unique<germanairlinesva::gaconnector::websocket::Websocket>(
configuration->getUser(), "wss://ws.hofmannnet.myhome-server.de:8000",
toLog); configuration->getUser(),
toLog);
toLog("WebSocket started"); toLog("WebSocket started");
char hash[2 * MD5LEN + 1] = ""; char hash[2 * MD5LEN + 1] = "";
if (germanairlinesva::util::generateMD5(XPLANE_CUSTOM_SCENERY, hash, toLog) == if (germanairlinesva::utilities::generateMD5(XPLANE_CUSTOM_SCENERY,
0) { hash,
toLog) == 0) {
database = std::make_unique<germanairlinesva::file::simdata::SimDatabase>( database = std::make_unique<germanairlinesva::file::simdata::SimDatabase>(
xplaneVersion, xplaneVersion,
hash, hash,
@ -216,7 +218,9 @@ float flightLoop(float elapsedMe, float elapsedSim, int counter, void *refcon)
{ {
const std::lock_guard<std::mutex> lock(mutex); const std::lock_guard<std::mutex> lock(mutex);
std::memset(&toSend, 0, sizeof(germanairlinesva::websocket::data)); std::memset(&toSend,
0,
sizeof(germanairlinesva::gaconnector::websocket::data));
toSend.pause = XPLMGetDatai(pauseIndicator); toSend.pause = XPLMGetDatai(pauseIndicator);
toSend.pBrake = XPLMGetDataf(parkingBrake); toSend.pBrake = XPLMGetDataf(parkingBrake);
@ -254,14 +258,16 @@ float flightLoop(float elapsedMe, float elapsedSim, int counter, void *refcon)
void serverWorker() void serverWorker()
{ {
germanairlinesva::util::setThreadName("GAServerWorker"); germanairlinesva::utilities::setThreadName("GAServerWorker");
while (!wantsExit) { while (!wantsExit) {
struct germanairlinesva::websocket::data copy; struct germanairlinesva::gaconnector::websocket::data copy;
{ {
const std::lock_guard<std::mutex> lock(mutex); const std::lock_guard<std::mutex> lock(mutex);
std::memcpy(&copy, &toSend, sizeof(germanairlinesva::websocket::data)); std::memcpy(&copy,
&toSend,
sizeof(germanairlinesva::gaconnector::websocket::data));
} }
connector->sendData(copy); connector->sendData(copy);
@ -274,7 +280,7 @@ void serverWorker()
void recordingWorker() void recordingWorker()
{ {
germanairlinesva::util::setThreadName("GARecordingWorker"); germanairlinesva::utilities::setThreadName("GARecordingWorker");
germanairlinesva::file::recording::RecordingEntry lastPath; germanairlinesva::file::recording::RecordingEntry lastPath;
std::uint32_t segment = 0; std::uint32_t segment = 0;
@ -283,11 +289,13 @@ void recordingWorker()
auto rwys = ap.second; auto rwys = ap.second;
while (!wantsExit) { while (!wantsExit) {
struct germanairlinesva::websocket::data copy; struct germanairlinesva::gaconnector::websocket::data copy;
{ {
const std::lock_guard<std::mutex> lock(mutex); const std::lock_guard<std::mutex> lock(mutex);
std::memcpy(&copy, &toSend, sizeof(germanairlinesva::websocket::data)); std::memcpy(&copy,
&toSend,
sizeof(germanairlinesva::gaconnector::websocket::data));
} }
germanairlinesva::file::recording::RecordingEntry currentPath( germanairlinesva::file::recording::RecordingEntry currentPath(