QGroundControlQmlGlobal.cc

Go to the documentation of this file.

#include "QGroundControlQmlGlobal.h"
 
#include "QGCCorePlugin.h"
#include "LinkManager.h"
#include "MAVLinkProtocol.h"
#include "FirmwarePluginManager.h"
#include "AppSettings.h"
#include "FlightMapSettings.h"
#include "SettingsManager.h"
#include "PositionManager.h"
#include "QGCMapEngineManager.h"
#include "ADSBVehicleManager.h"
#include "AudioOutput.h"
#include "NTRIPManager.h"
#include "MAVLinkSigningKeys.h"
#include "MissionCommandTree.h"
#include "VideoManager.h"
#include "MultiVehicleManager.h"
#include "LoggingCategoryModel.h"
#ifndef QGC_NO_SERIAL_LINK
#include "GPSManager.h"
#include "GPSRtk.h"
#endif
#ifdef QT_DEBUG
#include "MockLink.h"
#endif
 
#include <QtCore/QLineF>
#include <QtCore/QSettings>
#include <QtGui/QClipboard>
#include <QtGui/QGuiApplication>
 
#include "QGCLoggingCategory.h"
 
QGC_LOGGING_CATEGORY(GuidedActionsControllerLog, "QMLControls.GuidedActionsController")
 
QGeoCoordinate QGroundControlQmlGlobal::_coord = QGeoCoordinate(0.0,0.0);
double QGroundControlQmlGlobal::_zoom = 2;
 
QGroundControlQmlGlobal::QGroundControlQmlGlobal(QObject *parent)
    : QObject(parent)
    , _mapEngineManager(QGCMapEngineManager::instance())
    , _adsbVehicleManager(ADSBVehicleManager::instance())
    , _ntripManager(NTRIPManager::instance())
    , _qgcPositionManager(QGCPositionManager::instance())
    , _missionCommandTree(MissionCommandTree::instance())
    , _mavlinkSigningKeys(MAVLinkSigningKeys::instance())
    , _videoManager(VideoManager::instance())
    , _linkManager(LinkManager::instance())
    , _multiVehicleManager(MultiVehicleManager::instance())
    , _settingsManager(SettingsManager::instance())
    , _corePlugin(QGCCorePlugin::instance())
    , _globalPalette(new QGCPalette(this))
#ifndef QGC_NO_SERIAL_LINK
    , _gpsRtkFactGroup(GPSManager::instance()->gpsRtk()->gpsRtkFactGroup())
#endif
{
    // We clear the parent on this object since we run into shutdown problems caused by hybrid qml app. Instead we let it leak on shutdown.
    // setParent(nullptr);
 
    // Load last coordinates and zoom from config file
    QSettings settings;
    settings.beginGroup(_flightMapPositionSettingsGroup);
    _coord.setLatitude(settings.value(_flightMapPositionLatitudeSettingsKey,    _coord.latitude()).toDouble());
    _coord.setLongitude(settings.value(_flightMapPositionLongitudeSettingsKey,  _coord.longitude()).toDouble());
    _zoom = settings.value(_flightMapZoomSettingsKey, _zoom).toDouble();
    _flightMapPositionSettledTimer.setSingleShot(true);
    _flightMapPositionSettledTimer.setInterval(1000);
    (void) connect(&_flightMapPositionSettledTimer, &QTimer::timeout, this, []() {
        // When they settle, save flightMapPosition and Zoom to the config file
        QSettings settingsInner;
        settingsInner.beginGroup(_flightMapPositionSettingsGroup);
        settingsInner.setValue(_flightMapPositionLatitudeSettingsKey, _coord.latitude());
        settingsInner.setValue(_flightMapPositionLongitudeSettingsKey, _coord.longitude());
        settingsInner.setValue(_flightMapZoomSettingsKey, _zoom);
    });
    connect(this, &QGroundControlQmlGlobal::flightMapPositionChanged, this, [this](QGeoCoordinate){
        if (!_flightMapPositionSettledTimer.isActive()) {
            _flightMapPositionSettledTimer.start();
        }
    });
    connect(this, &QGroundControlQmlGlobal::flightMapZoomChanged, this, [this](double){
        if (!_flightMapPositionSettledTimer.isActive()) {
            _flightMapPositionSettledTimer.start();
        }
    });
}
 
QGroundControlQmlGlobal::~QGroundControlQmlGlobal()
{
}
 
void QGroundControlQmlGlobal::saveGlobalSetting (const QString& key, const QString& value)
{
    QSettings settings;
    settings.beginGroup(kQmlGlobalKeyName);
    settings.setValue(key, value);
}
 
QString QGroundControlQmlGlobal::loadGlobalSetting (const QString& key, const QString& defaultValue)
{
    QSettings settings;
    settings.beginGroup(kQmlGlobalKeyName);
    return settings.value(key, defaultValue).toString();
}
 
void QGroundControlQmlGlobal::saveBoolGlobalSetting (const QString& key, bool value)
{
    QSettings settings;
    settings.beginGroup(kQmlGlobalKeyName);
    settings.setValue(key, value);
}
 
bool QGroundControlQmlGlobal::loadBoolGlobalSetting (const QString& key, bool defaultValue)
{
    QSettings settings;
    settings.beginGroup(kQmlGlobalKeyName);
    return settings.value(key, defaultValue).toBool();
}
 
#ifdef QT_DEBUG
static MockConfiguration::Options _mockLinkOptions(bool sendStatusText, bool enableCamera, bool enableGimbal, bool enableProximity, bool apmStartFreshParams = false)
{
    MockConfiguration::Options options = MockConfiguration::OptionNone;
    options.setFlag(MockConfiguration::OptionSendStatusText, sendStatusText);
    options.setFlag(MockConfiguration::OptionEnableCamera, enableCamera);
    options.setFlag(MockConfiguration::OptionEnableGimbal, enableGimbal);
    options.setFlag(MockConfiguration::OptionEnableProximity, enableProximity);
    options.setFlag(MockConfiguration::OptionAPMStartFreshParams, apmStartFreshParams);
    return options;
}
#endif
 
void QGroundControlQmlGlobal::startPX4MockLink(bool sendStatusText, bool enableCamera, bool enableGimbal, bool enableProximity, int videoStreamType)
{
#ifdef QT_DEBUG
    MockLink::startPX4MockLink(_mockLinkOptions(sendStatusText, enableCamera, enableGimbal, enableProximity), MockConfiguration::FailNone, MockConfiguration::videoStreamTypeFromInt(videoStreamType));
#else
    Q_UNUSED(sendStatusText);
    Q_UNUSED(enableCamera);
    Q_UNUSED(enableGimbal);
    Q_UNUSED(enableProximity);
    Q_UNUSED(videoStreamType);
#endif
}
 
void QGroundControlQmlGlobal::startGenericMockLink(bool sendStatusText, bool enableCamera, bool enableGimbal, bool enableProximity, int videoStreamType)
{
#ifdef QT_DEBUG
    MockLink::startGenericMockLink(_mockLinkOptions(sendStatusText, enableCamera, enableGimbal, enableProximity), MockConfiguration::FailNone, MockConfiguration::videoStreamTypeFromInt(videoStreamType));
#else
    Q_UNUSED(sendStatusText);
    Q_UNUSED(enableCamera);
    Q_UNUSED(enableGimbal);
    Q_UNUSED(enableProximity);
    Q_UNUSED(videoStreamType);
#endif
}
 
void QGroundControlQmlGlobal::startAPMArduCopterMockLink(bool sendStatusText, bool enableCamera, bool enableGimbal, bool enableProximity, bool apmStartFreshParams, int videoStreamType)
{
#ifdef QT_DEBUG
    MockLink::startAPMArduCopterMockLink(_mockLinkOptions(sendStatusText, enableCamera, enableGimbal, enableProximity, apmStartFreshParams), MockConfiguration::FailNone, MockConfiguration::videoStreamTypeFromInt(videoStreamType));
#else
    Q_UNUSED(sendStatusText);
    Q_UNUSED(enableCamera);
    Q_UNUSED(enableGimbal);
    Q_UNUSED(enableProximity);
    Q_UNUSED(apmStartFreshParams);
    Q_UNUSED(videoStreamType);
#endif
}
 
void QGroundControlQmlGlobal::startAPMArduPlaneMockLink(bool sendStatusText, bool enableCamera, bool enableGimbal, bool enableProximity, bool apmStartFreshParams, int videoStreamType)
{
#ifdef QT_DEBUG
    MockLink::startAPMArduPlaneMockLink(_mockLinkOptions(sendStatusText, enableCamera, enableGimbal, enableProximity, apmStartFreshParams), MockConfiguration::FailNone, MockConfiguration::videoStreamTypeFromInt(videoStreamType));
#else
    Q_UNUSED(sendStatusText);
    Q_UNUSED(enableCamera);
    Q_UNUSED(enableGimbal);
    Q_UNUSED(enableProximity);
    Q_UNUSED(apmStartFreshParams);
    Q_UNUSED(videoStreamType);
#endif
}
 
void QGroundControlQmlGlobal::startAPMArduSubMockLink(bool sendStatusText, bool enableCamera, bool enableGimbal, bool enableProximity, bool apmStartFreshParams, int videoStreamType)
{
#ifdef QT_DEBUG
    MockLink::startAPMArduSubMockLink(_mockLinkOptions(sendStatusText, enableCamera, enableGimbal, enableProximity, apmStartFreshParams), MockConfiguration::FailNone, MockConfiguration::videoStreamTypeFromInt(videoStreamType));
#else
    Q_UNUSED(sendStatusText);
    Q_UNUSED(enableCamera);
    Q_UNUSED(enableGimbal);
    Q_UNUSED(enableProximity);
    Q_UNUSED(apmStartFreshParams);
    Q_UNUSED(videoStreamType);
#endif
}
 
void QGroundControlQmlGlobal::startAPMArduRoverMockLink(bool sendStatusText, bool enableCamera, bool enableGimbal, bool enableProximity, bool apmStartFreshParams, int videoStreamType)
{
#ifdef QT_DEBUG
    MockLink::startAPMArduRoverMockLink(_mockLinkOptions(sendStatusText, enableCamera, enableGimbal, enableProximity, apmStartFreshParams), MockConfiguration::FailNone, MockConfiguration::videoStreamTypeFromInt(videoStreamType));
#else
    Q_UNUSED(sendStatusText);
    Q_UNUSED(enableCamera);
    Q_UNUSED(enableGimbal);
    Q_UNUSED(enableProximity);
    Q_UNUSED(apmStartFreshParams);
    Q_UNUSED(videoStreamType);
#endif
}
 
void QGroundControlQmlGlobal::stopOneMockLink(void)
{
#ifdef QT_DEBUG
    QList<SharedLinkInterfacePtr> sharedLinks = LinkManager::instance()->links();
 
    for (int i=0; i<sharedLinks.count(); i++) {
        LinkInterface* link = sharedLinks[i].get();
        MockLink* mockLink = qobject_cast<MockLink*>(link);
        if (mockLink) {
            mockLink->disconnect();
            return;
        }
    }
#endif
}
 
bool QGroundControlQmlGlobal::singleFirmwareSupport(void)
{
    return FirmwarePluginManager::instance()->supportedFirmwareClasses().count() == 1;
}
 
bool QGroundControlQmlGlobal::singleVehicleSupport(void)
{
    if (singleFirmwareSupport()) {
        return FirmwarePluginManager::instance()->supportedVehicleClasses(FirmwarePluginManager::instance()->supportedFirmwareClasses()[0]).count() == 1;
    }
 
    return false;
}
 
bool QGroundControlQmlGlobal::px4ProFirmwareSupported()
{
    return FirmwarePluginManager::instance()->firmwareClassSupported(QGCMAVLink::FirmwareClassPX4);
}
 
bool QGroundControlQmlGlobal::apmFirmwareSupported()
{
    return FirmwarePluginManager::instance()->firmwareClassSupported(QGCMAVLink::FirmwareClassArduPilot);
}
 
bool QGroundControlQmlGlobal::linesIntersect(QPointF line1A, QPointF line1B, QPointF line2A, QPointF line2B)
{
    QPointF intersectPoint;
 
    auto intersect = QLineF(line1A, line1B).intersects(QLineF(line2A, line2B), &intersectPoint);
 
    return  intersect == QLineF::BoundedIntersection &&
            intersectPoint != line1A && intersectPoint != line1B;
}
 
void QGroundControlQmlGlobal::setFlightMapPosition(QGeoCoordinate& coordinate)
{
    if (coordinate != flightMapPosition()) {
        _coord.setLatitude(coordinate.latitude());
        _coord.setLongitude(coordinate.longitude());
        emit flightMapPositionChanged(coordinate);
    }
}
 
void QGroundControlQmlGlobal::setFlightMapZoom(double zoom)
{
    if (zoom != flightMapZoom()) {
        _zoom = zoom;
        emit flightMapZoomChanged(zoom);
    }
}
 
QString QGroundControlQmlGlobal::qgcVersion(void)
{
    QString versionStr = QCoreApplication::applicationVersion();
    if(QSysInfo::buildAbi().contains("32"))
    {
        versionStr += QStringLiteral(" %1").arg(tr("32 bit"));
    }
    else if(QSysInfo::buildAbi().contains("64"))
    {
        versionStr += QStringLiteral(" %1").arg(tr("64 bit"));
    }
    return versionStr;
}
 
QString QGroundControlQmlGlobal::altitudeFrameExtraUnits(AltitudeFrame altFrame)
{
    switch (altFrame) {
    case AltitudeFrameNone:
        return QString();
    case AltitudeFrameRelative:
        return tr("Rel");
    case AltitudeFrameAbsolute:
        return tr("AMSL");
    case AltitudeFrameCalcAboveTerrain:
        return tr("AGLC");
    case AltitudeFrameTerrain:
        return tr("AGL");
    case AltitudeFrameMixed:
        return tr("Mixed");
    }
 
    // Should never get here but makes some compilers happy
    return QString();
}
 
QString QGroundControlQmlGlobal::altitudeFrameShortDescription(AltitudeFrame altFrame)
{
    switch (altFrame) {
    case AltitudeFrameNone:
        return QString();
    case AltitudeFrameRelative:
        return tr("Relative (%1)").arg(altitudeFrameExtraUnits(altFrame));
    case AltitudeFrameAbsolute:
        return tr("Absolute (%1)").arg(altitudeFrameExtraUnits(altFrame));
    case AltitudeFrameCalcAboveTerrain:
        return tr("Above Terrain Calced (%1)").arg(altitudeFrameExtraUnits(altFrame));
    case AltitudeFrameTerrain:
        return tr("Above Terrain (%1)").arg(altitudeFrameExtraUnits(altFrame));
    case AltitudeFrameMixed:
        return tr("Mixed");
    }
 
    // Should never get here but makes some compilers happy
    return QString();
}
 
void QGroundControlQmlGlobal::showMessageDialog(
    QObject* owner,
    const QString& title,
    const QString& text,
    int buttons,
    QJSValue acceptFunction,
    QJSValue closeFunction)
{
    emit showMessageDialogRequested(owner, title, text, buttons, acceptFunction, closeFunction);
}
 
void QGroundControlQmlGlobal::testAudioOutput()
{
    AudioOutput::instance()->testAudioOutput();
}
 
void QGroundControlQmlGlobal::copyToClipboard(const QString& text)
{
    QGuiApplication::clipboard()->setText(text);
}
 
QString QGroundControlQmlGlobal::elevationProviderName()
{
    return _settingsManager->flightMapSettings()->elevationMapProvider()->rawValue().toString();
}
 
QString QGroundControlQmlGlobal::elevationProviderNotice()
{
    return _settingsManager->flightMapSettings()->elevationMapProvider()->rawValue().toString();
}
 
QString QGroundControlQmlGlobal::parameterFileExtension() const
{
    return AppSettings::parameterFileExtension;
}
 
QString QGroundControlQmlGlobal::telemetryFileExtension() const
{
    return AppSettings::telemetryFileExtension;
}
 
QString QGroundControlQmlGlobal::appName()
{
    return QCoreApplication::applicationName();
}