TrafficDataProvider.h

/***************************************************************************
 *   Copyright (C) 2021-2026 by Stefan Kebekus                             *
 *   stefan.kebekus@gmail.com                                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#pragma once
 
#include <QNetworkDatagram>
#include <QStandardPaths>
#include <QUdpSocket>
 
#include "GlobalObject.h"
#include "traffic/ConnectionInfo.h"
#include "traffic/TrafficDataSource_Abstract.h"
 
namespace Traffic {

class TrafficDataProvider : public QObject {
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
 
public:
    explicit TrafficDataProvider(QObject *parent = nullptr);
 
    // No default constructor, important for QML singleton
    explicit TrafficDataProvider() = delete;
 
    // factory function for QML singleton
    static Traffic::TrafficDataProvider* create(QQmlEngine* /*unused*/, QJSEngine* /*unused*/)
    {
        return GlobalObject::trafficDataProvider();
    }
 
    // Standard destructor
    ~TrafficDataProvider() override;
 
    //
    // Properties
    //

    Q_PROPERTY(QList<Traffic::ConnectionInfo> connectionInfos READ connectionInfos BINDABLE bindableConnectionInfos NOTIFY connectionInfosChanged)
 
    
    Q_PROPERTY(bool currentSourceIsInternetService READ currentSourceIsInternetService BINDABLE bindableCurrentSourceIsInternetService);

    Q_PROPERTY(QList<Traffic::TrafficDataSource_Abstract*> dataSources READ dataSources NOTIFY dataSourcesChanged)

    Q_PROPERTY(Positioning::PositionInfo positionInfo READ positionInfo BINDABLE bindablePositionInfo)

    Q_PROPERTY(Units::Distance pressureAltitude READ pressureAltitude BINDABLE bindablePressureAltitude)

    Q_PROPERTY(bool receivingHeartbeat READ receivingHeartbeat BINDABLE bindableReceivingHeartbeat NOTIFY receivingHeartbeatChanged)

    Q_PROPERTY(QString statusString READ statusString BINDABLE bindableStatusString)

    Q_PROPERTY(QList<Traffic::TrafficFactor_WithPosition*> trafficObjects READ trafficObjects CONSTANT)

    Q_PROPERTY(Traffic::TrafficFactor_DistanceOnly* trafficObjectWithoutPosition READ trafficObjectWithoutPosition CONSTANT)

    Q_PROPERTY(QString trafficReceiverRuntimeError READ trafficReceiverRuntimeError NOTIFY trafficReceiverRuntimeErrorChanged)

    Q_PROPERTY(QString trafficReceiverSelfTestError READ trafficReceiverSelfTestError NOTIFY trafficReceiverSelfTestErrorChanged)

    Q_PROPERTY(Traffic::Warning warning READ warning NOTIFY warningChanged)
 
 
    //
    // Getter Methods
    //

    [[nodiscard]] QList<Traffic::ConnectionInfo> connectionInfos() const {return m_connectionInfos.value();}

    [[nodiscard]] QBindable<QList<Traffic::ConnectionInfo>> bindableConnectionInfos() {return &m_connectionInfos;}

    [[nodiscard]] bool currentSourceIsInternetService() const {return m_currentSourceIsInternetService.value();}

    [[nodiscard]] QBindable<bool> bindableCurrentSourceIsInternetService() {return &m_currentSourceIsInternetService;}

    [[nodiscard]] QList<Traffic::TrafficDataSource_Abstract*> dataSources() const;

    [[nodiscard]] Positioning::PositionInfo positionInfo() const
    {
        return m_positionInfo.value();
    }

    [[nodiscard]] QBindable<Positioning::PositionInfo> bindablePositionInfo() {return &m_positionInfo;}

    [[nodiscard]] Units::Distance pressureAltitude() const {return m_pressureAltitude.value();}

    [[nodiscard]] QBindable<Units::Distance> bindablePressureAltitude() {return &m_pressureAltitude;}

    [[nodiscard]] bool receivingHeartbeat() const
    {
        return m_receivingHeartbeat.value();
    }

    [[nodiscard]] QBindable<bool> bindableReceivingHeartbeat() {return &m_receivingHeartbeat;}

    [[nodiscard]] QString statusString() const
    {
        return m_statusString.value();
    }

    [[nodiscard]] QBindable<QString> bindableStatusString() {return &m_statusString;}

    [[nodiscard]] QList<Traffic::TrafficFactor_WithPosition*> trafficObjects() const
    {
        return m_trafficObjects;
    }

    [[nodiscard]] Traffic::TrafficFactor_DistanceOnly* trafficObjectWithoutPosition() const
    {
        return m_trafficObjectWithoutPosition;
    }

    [[nodiscard]] QString trafficReceiverRuntimeError() const
    {
        return m_trafficReceiverRuntimeError.value();
    }

    [[nodiscard]] QString trafficReceiverSelfTestError() const
    {
        return m_trafficReceiverSelfTestError.value();
    }

    [[nodiscard]] Traffic::Warning warning() const
    {
        return m_Warning;
    }
 
 
    //
    // Methods
    //

    void addDataSource(Traffic::TrafficDataSource_Abstract* source);

    Q_INVOKABLE QString addDataSource(const Traffic::ConnectionInfo &connectionInfo);

    Q_INVOKABLE QString addDataSource_UDP(quint16 port);

    Q_INVOKABLE QString addDataSource_SerialPort(const QString& portNameOrDescription,
                                                 ConnectionInfo::BaudRate baudRate,
                                                 ConnectionInfo::StopBits stopBits,
                                                 ConnectionInfo::FlowControl flowControl);

    Q_INVOKABLE QString addDataSource_TCP(const QString& host, quint16 port);

    Q_INVOKABLE QString addDataSource_OGN();

    Q_INVOKABLE bool hasDataSource_SerialPort(const QString& portNameOrDescription);

    Q_INVOKABLE void removeDataSource(Traffic::TrafficDataSource_Abstract* source);

    Q_INVOKABLE void removeDataSources();
 
 
signals:
    void connectionInfosChanged();

    void dataSourcesChanged();

    void passwordRequest(const QString& SSID);

    void passwordStorageRequest(const QString& SSID, const QString& password);

    void receivingHeartbeatChanged();

    void trafficReceiverRuntimeErrorChanged();

    void trafficReceiverSelfTestErrorChanged();

    void warningChanged(const Traffic::Warning&);
 
public slots:
    void connectToTrafficReceiver();

    void disconnectFromTrafficReceiver();

    void setPassword(const QString& SSID, const QString &password);
 
private slots:
    // Identical to addDataSource, but handles Bluetooth Classic connections only.
    QString addDataSource_BluetoothClassic(const Traffic::ConnectionInfo &connectionInfo);
 
    // Identical to addDataSource, but handles Bluetooth Low Energy connections only.
    QString addDataSource_BluetoothLowEnergy(const Traffic::ConnectionInfo &connectionInfo);
 
    // Intializations that are moved out of the constructor, in order to avoid
    // nested uses of constructors in Global.
    void deferredInitialization();
 
    // Sends out foreflight broadcast message See
    // https://www.foreflight.com/connect/spec/
    void foreFlightBroadcast();
 
    // Load connection infos from file and create connections
    void loadConnectionInfos();
 
    // Called if one of the sources indicates a heartbeat change
    void onCurrentSourceChanged();
 
    // Called if one of the sources reports traffic (position known)
    void onTrafficFactorWithPosition(const Traffic::TrafficFactorData_WithPosition& factor);
 
    // Called if one of the sources reports traffic (position unknown)
    void onTrafficFactorWithoutPosition(const Traffic::TrafficFactorData_DistanceOnly& factor);
 
    // Resetter method
    void resetWarning();
 
    // Save connection infos to file
    void saveConnectionInfos();
 
    // Setter method
    void setWarning(const Traffic::Warning& warning);
 
private:
    Q_DISABLE_COPY_MOVE(TrafficDataProvider)
 
    //
    // Compute Methods
    //
 
 
    QProperty<QString> m_statusString;
    QString computeStatusString();
 
    // UDP Socket for ForeFlight Broadcast messages.
    // See https://www.foreflight.com/connect/spec/
    QNetworkDatagram foreFlightBroadcastDatagram = {R"({"App":"Enroute Flight Navigation","GDL90":{"port":4000}})", QHostAddress::Broadcast, 63093};
    QUdpSocket foreFlightBroadcastSocket;
    QTimer foreFlightBroadcastTimer;
 
    // Targets
    QList<Traffic::TrafficFactor_WithPosition *> m_trafficObjects;
    QPointer<Traffic::TrafficFactor_DistanceOnly> m_trafficObjectWithoutPosition;
 
    // TrafficData Sources
    QProperty<QList<QPointer<Traffic::TrafficDataSource_Abstract>>> m_dataSources;
 
    // Cached, alphabetically sorted view of m_dataSources exposed via the
    // dataSources property. Recomputed (and dataSourcesChanged emitted) whenever
    // m_dataSources changes.
    Q_OBJECT_BINDABLE_PROPERTY(Traffic::TrafficDataProvider, QList<Traffic::TrafficDataSource_Abstract*>, m_dataSourcesCache, &Traffic::TrafficDataProvider::dataSourcesChanged);
    QList<Traffic::TrafficDataSource_Abstract*> computeDataSources();
 
    QProperty<QPointer<Traffic::TrafficDataSource_Abstract>> m_currentSource;
    QPropertyNotifier m_currentSourceNotifier;
    QPointer<Traffic::TrafficDataSource_Abstract> computeCurrentSource();
 
    QProperty<bool> m_currentSourceIsInternetService;
 
    // Property cache
    Traffic::Warning m_Warning;
    QTimer m_WarningTimer;
 
    Q_OBJECT_BINDABLE_PROPERTY(Traffic::TrafficDataProvider, QList<Traffic::ConnectionInfo>, m_connectionInfos, &Traffic::TrafficDataProvider::connectionInfosChanged);
    QList<Traffic::ConnectionInfo> computeConnectionInfos();
 
    Q_OBJECT_BINDABLE_PROPERTY(Traffic::TrafficDataProvider, QString, m_trafficReceiverRuntimeError, &Traffic::TrafficDataProvider::trafficReceiverRuntimeErrorChanged);
    QString computeTrafficReceiverRuntimeError();
 
    Q_OBJECT_BINDABLE_PROPERTY(Traffic::TrafficDataProvider, QString, m_trafficReceiverSelfTestError, &Traffic::TrafficDataProvider::trafficReceiverSelfTestErrorChanged);
    QString computeTrafficReceiverSelfTestError();
 
    QProperty<Positioning::PositionInfo> m_positionInfo;
    Positioning::PositionInfo computePositionInfo();
 
    QProperty<Units::Distance> m_pressureAltitude;
    Units::Distance computePressureAltitude();
 
    // Reconnect
    QTimer reconnectionTimer;
 
    Q_OBJECT_BINDABLE_PROPERTY(Traffic::TrafficDataProvider, bool, m_receivingHeartbeat, &Traffic::TrafficDataProvider::receivingHeartbeatChanged);
    bool computeReceivingHeartbeat();
 
    // Standard file name for saveConnectionInfos()
    QString stdFileName = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + u"/connectionInfos.data"_s;
};
 
} // namespace Traffic