TrafficDataSource_Abstract.h

/***************************************************************************
 *   Copyright (C) 2021-2025 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 <QProperty>
 
#include "positioning/PositionInfo.h"
#include "traffic/ConnectionInfo.h"
#include "traffic/TrafficFactor_DistanceOnly.h"
#include "traffic/TrafficFactor_WithPosition.h"
#include "traffic/Warning.h"
 
 
namespace Traffic {

class TrafficDataSource_Abstract : public QObject {
    Q_OBJECT
 
public:
    TrafficDataSource_Abstract(bool isCanonical, QObject* parent);
 
    // Standard destructor
    ~TrafficDataSource_Abstract() override = default;
 
 
    //
    // Properties
    //

    Q_PROPERTY(bool canonical READ canonical CONSTANT)
 
    
    Q_PROPERTY(QString connectivityStatus READ connectivityStatus WRITE setConnectivityStatus NOTIFY connectivityStatusChanged)

    Q_PROPERTY(Traffic::ConnectionInfo connectionInfo READ connectionInfo BINDABLE bindableConnectionInfo)

    Q_PROPERTY(QString dataFormat READ dataFormat CONSTANT)

    Q_PROPERTY(QString errorString READ errorString WRITE setErrorString NOTIFY errorStringChanged)

    Q_PROPERTY(QString icon READ icon CONSTANT)

    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 WRITE setReceivingHeartbeat RESET resetReceivingHeartbeat NOTIFY receivingHeartbeatChanged)

    Q_PROPERTY(QString sourceName READ sourceName CONSTANT)

    Q_PROPERTY(QString trafficReceiverRuntimeError READ trafficReceiverRuntimeError BINDABLE bindableTrafficReceiverRuntimeError)

    Q_PROPERTY(QString trafficReceiverSelfTestError READ trafficReceiverSelfTestError BINDABLE bindableTrafficReceiverSelfTestError)
 
 
 
    //
    // Getter methods
    //

    [[nodiscard]] bool canonical() const
    {
        return m_canonical;
    }

    [[nodiscard]] Traffic::ConnectionInfo connectionInfo() const { return m_connectionInfo.value(); }

    [[nodiscard]] QBindable<Traffic::ConnectionInfo> bindableConnectionInfo() const { return &m_connectionInfo; }

    [[nodiscard]] QString connectivityStatus() const
    {
        return m_connectivityStatus;
    }

    [[nodiscard]] virtual QString dataFormat() const = 0;

    [[nodiscard]] QString errorString() const
    {
        return m_errorString;
    }

    [[nodiscard]] virtual QString icon() const = 0;

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

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

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

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

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

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

    [[nodiscard]] virtual QString sourceName() const = 0;

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

    [[nodiscard]] QBindable<QString> bindableTrafficReceiverRuntimeError()
    {
        return &m_trafficReceiverRuntimeError;
    }

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

    [[nodiscard]] QBindable<QString> bindableTrafficReceiverSelfTestError()
    {
        return &m_trafficReceiverSelfTestError;
    }
 
 
signals:
    void connectivityStatusChanged(QString newStatus);

    void dataReceived(QString data);

    void errorStringChanged(QString newError);

    void factorWithoutPosition(const Traffic::TrafficFactor_DistanceOnly &factor);

    void factorWithPosition(const Traffic::TrafficFactor_WithPosition& factor);
 
    /* \brief Password request
     *
     *  This signal is emitted whenever the traffic receiver asks for a
     *  password. Note that this is not the WiFi-Password.
     *
     *  @param SSID Name of the WiFi network that is currently in use.
     */
    void passwordRequest(const QString& SSID);
 
    /* \brief Password storage request
     *
     *  This signal is emitted whenever the traffic receiver has successfully
     *  connected using a password that was not yet in the database.
     *
     *  @param SSID Name of the WiFi network that is was used in use.
     */
    void passwordStorageRequest(const QString& SSID, const QString& password);

    void receivingHeartbeatChanged(bool);

    void trafficReceiverHwVersion(QString result);

    void trafficReceiverObVersion(QString result);

    void trafficReceiverSwVersion(QString result);

    void warning(const Traffic::Warning& warning);
 
public slots:
    virtual void connectToTrafficReceiver() = 0;

    virtual void disconnectFromTrafficReceiver() = 0;

    virtual void setPassword(const QString& SSID, const QString& password)
    {
        Q_UNUSED(SSID)
        Q_UNUSED(password)
    }
 
protected:
    void processAPRS(const QString& data);

    void processFLARMData(const QString& data);

    void processGDLMessage(const QByteArray& message);

    void processXGPSString(const QByteArray& data);

    void resetReceivingHeartbeat();

    void setConnectivityStatus(const QString& newConnectivityStatus);

    void setErrorString(const QString& newErrorString = QString());

    void setPositionInfo(const Positioning::PositionInfo& info);

    void setPressureAltitude(Units::Distance newPressureAltitude);

    void setReceivingHeartbeat(bool newReceivingHeartbeat);
 
protected:
    QProperty<QString> m_trafficReceiverRuntimeError;
    QProperty<QString> m_trafficReceiverSelfTestError;
    QProperty<Traffic::ConnectionInfo> m_connectionInfo;
 
private:
    Q_DISABLE_COPY_MOVE(TrafficDataSource_Abstract)
 
    /*  This method expects exactly one line containing a valid FLARM/NMEA
     *  sentence. This is a string typically looks like
     *  "$PFLAA,0,1587,1588,40,1,AA1237,225,,37,-1.6,1*7F".  The method
     *  interprets the string and updates the properties and emits signals as
     *  appropriate. Invalid strings are silently ignored.
     */
    void processFLARMSentence(const QString& sentence);
    // Methods interpreting specific FLARM/NMEA messages
    void processFLARMMessageGPGGA(const QStringList& arguments); // NMEA GPS 3D-fix data
    void processFLARMMessageGPRMC(const QStringList& arguments); // Recommended minimum specific GPS/Transit data
    void processFLARMMessagePFLAA(const QStringList& arguments); // Data on other proximate aircraft
    void processFLARMMessagePFLAE(const QStringList& arguments); // Self-test result and errors codes
    static void processFLARMMessagePFLAS(const QStringList& arguments); // Debug Information
    void processFLARMMessagePFLAU(const QStringList& arguments); // FLARM Heartbeat
    void processFLARMMessagePFLAV(const QStringList& arguments); // Version information
    void processFLARMMessagePGRMZ(const QStringList& arguments); // Garmin's barometric altitude
    static void processFLARMMessagePXCV(const QStringList& arguments); // XCVario
    QString m_FLARMDataBuffer;
 
    // Property caches
    bool m_canonical {false};
    QString m_connectivityStatus;
    QString m_errorString;
 
    // True altitude of own aircraft. We store these values because the
    // necessary information to compile a PositionInfo class does not always
    // come in one piece.  Whenever a valid altitude is set, the timer should be
    // started. The timer can then be used to check if the altitude information
    // is recent enough to be used. Whenever an invalid altitude is set, the
    // timer should be stopped.
    Units::Distance m_trueAltitude;
    Units::Distance m_trueAltitudeFOM; // Fig. of Merit
    QTimer m_trueAltitudeTimer;
 
    // Pressure altitude of own aircraft. The timer will reset the pressureAltitude
    // to an invalid value if no data is received for a while.
    QProperty<Units::Distance> m_pressureAltitude;
    QTimer m_pressureAltitudeTimer;
 
    // Heartbeat timer
    Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(Traffic::TrafficDataSource_Abstract, bool, m_receivingHeartbeat, false, &Traffic::TrafficDataSource_Abstract::receivingHeartbeatChanged);
    QTimer m_heartbeatTimer;
 
    // Targets
    Traffic::TrafficFactor_WithPosition m_factor;
    Traffic::TrafficFactor_DistanceOnly m_factorDistanceOnly;
 
    // Position Info for ownship
    QProperty<Positioning::PositionInfo> m_positionInfo;
    QTimer m_positionInfoTimer;
};
 
} // namespace Traffic