SettingsManager.cc

Go to the documentation of this file.

#include "SettingsManager.h"
 
#include <QtCore/QApplicationStatic>
#include <QtCore/QRegularExpression>
 
#include "ADSBVehicleManagerSettings.h"
#include "APMMavlinkStreamRateSettings.h"
#include "AppMessages.h"
#include "AppSettings.h"
#include "AutoConnectSettings.h"
#include "BatteryIndicatorSettings.h"
#include "FirmwareUpgradeSettings.h"
#include "FlightMapSettings.h"
#include "FlightModeSettings.h"
#include "FlyViewSettings.h"
#include "GPSCorrectionSettings.h"
#include "GimbalControllerSettings.h"
#include "JoystickManagerSettings.h"
#include "JsonParsing.h"
#include "LogManagerSettings.h"
#include "LogViewerSettings.h"
#include "MapsSettings.h"
#include "MavlinkActionsSettings.h"
#include "MavlinkSettings.h"
#include "NTRIPSettings.h"
#include "OfflineMapsSettings.h"
#include "PlanViewSettings.h"
#include "QGCCorePlugin.h"
#include "QGCLoggingCategory.h"
#include "RTKSettings.h"
#include "RemoteIDSettings.h"
#include "SettingsGroup.h"
#include "UnitsSettings.h"
#include "VideoSettings.h"
#include "Viewer3DSettings.h"
 
QGC_LOGGING_CATEGORY(SettingsManagerLog, "Utilities.SettingsManager")
 
Q_APPLICATION_STATIC(SettingsManager, _settingsManagerInstance);
 
SettingsManager::SettingsManager(QObject *parent)
    : QQmlPropertyMap(this, parent)
{
    qCDebug(SettingsManagerLog) << this;
}
 
SettingsManager::~SettingsManager()
{
    qCDebug(SettingsManagerLog) << this;
}
 
SettingsManager *SettingsManager::instance()
{
    return _settingsManagerInstance();
}
 
void SettingsManager::init()
{
    _unitsSettings = new UnitsSettings(this); // Must be first since AppSettings references it
 
    _appSettings = new AppSettings(this);
    _loadSettingsFiles();
 
    _autoConnectSettings = new AutoConnectSettings(this);
    _batteryIndicatorSettings = new BatteryIndicatorSettings(this);
    _mavlinkActionsSettings = new MavlinkActionsSettings(this);
    _firmwareUpgradeSettings = new FirmwareUpgradeSettings(this);
    _flightMapSettings = new FlightMapSettings(this);
    _flightModeSettings = new FlightModeSettings(this);
    _flyViewSettings = new FlyViewSettings(this);
    _gimbalControllerSettings = new GimbalControllerSettings(this);
    _mapsSettings = new MapsSettings(this);
    _offlineMapsSettings = new OfflineMapsSettings(this);
    _planViewSettings = new PlanViewSettings(this);
    _remoteIDSettings = new RemoteIDSettings(this);
    _rtkSettings = new RTKSettings(this);
    _gpsCorrectionSettings = new GPSCorrectionSettings(this);
    _ntripSettings = new NTRIPSettings(this);
    _videoSettings = new VideoSettings(this);
    _mavlinkSettings = new MavlinkSettings(this);
    _joystickManagerSettings = new JoystickManagerSettings(this);
    _logManagerSettings = new LogManagerSettings(this);
    _logViewerSettings = new LogViewerSettings(this);
    _viewer3DSettings = new Viewer3DSettings(this);
    _adsbVehicleManagerSettings = new ADSBVehicleManagerSettings(this);
    _apmMavlinkStreamRateSettings = new APMMavlinkStreamRateSettings(this);
 
    QGCCorePlugin::instance()->registerCustomSettings(this);
}
 
void SettingsManager::registerCustomSettingsGroup(const QString &accessorName, SettingsGroup *group)
{
    // Must be a valid QML identifier or generated pages can't resolve the group via dot notation
    static const QRegularExpression validAccessorRe(QStringLiteral("^[a-z_][A-Za-z0-9_]*$"));
    if (!validAccessorRe.match(accessorName).hasMatch() || !group) {
        qCWarning(SettingsManagerLog) << "registerCustomSettingsGroup: invalid accessor name or null group" << accessorName;
        delete group;
        return;
    }
    if (contains(accessorName)) {
        qCWarning(SettingsManagerLog) << "registerCustomSettingsGroup: accessor already registered" << accessorName;
        // Re-registering the stored group itself must not destroy it
        if (group != value(accessorName).value<QObject*>()) {
            delete group;
        }
        return;
    }
    if (staticMetaObject.indexOfProperty(accessorName.toUtf8().constData()) != -1) {
        qCWarning(SettingsManagerLog) << "registerCustomSettingsGroup: accessor collides with a built-in settings group" << accessorName;
        delete group;
        return;
    }
 
    group->setParent(this);
    insert(accessorName, QVariant::fromValue<QObject*>(group));
    qCDebug(SettingsManagerLog) << "Registered custom settings group" << accessorName;
}
 
ADSBVehicleManagerSettings *SettingsManager::adsbVehicleManagerSettings() const { return _adsbVehicleManagerSettings; }
APMMavlinkStreamRateSettings *SettingsManager::apmMavlinkStreamRateSettings() const { return _apmMavlinkStreamRateSettings; }
AppSettings *SettingsManager::appSettings() const { return _appSettings; }
AutoConnectSettings *SettingsManager::autoConnectSettings() const { return _autoConnectSettings; }
BatteryIndicatorSettings *SettingsManager::batteryIndicatorSettings() const { return _batteryIndicatorSettings; }
MavlinkActionsSettings *SettingsManager::mavlinkActionsSettings() const { return _mavlinkActionsSettings; }
FirmwareUpgradeSettings *SettingsManager::firmwareUpgradeSettings() const { return _firmwareUpgradeSettings; }
FlightMapSettings *SettingsManager::flightMapSettings() const { return _flightMapSettings; }
FlightModeSettings *SettingsManager::flightModeSettings() const { return _flightModeSettings; }
FlyViewSettings *SettingsManager::flyViewSettings() const { return _flyViewSettings; }
GimbalControllerSettings *SettingsManager::gimbalControllerSettings() const { return _gimbalControllerSettings; }
MapsSettings *SettingsManager::mapsSettings() const { return _mapsSettings; }
OfflineMapsSettings *SettingsManager::offlineMapsSettings() const { return _offlineMapsSettings; }
PlanViewSettings *SettingsManager::planViewSettings() const { return _planViewSettings; }
RemoteIDSettings *SettingsManager::remoteIDSettings() const { return _remoteIDSettings; }
RTKSettings *SettingsManager::rtkSettings() const { return _rtkSettings; }
UnitsSettings *SettingsManager::unitsSettings() const { return _unitsSettings; }
NTRIPSettings *SettingsManager::ntripSettings() const { return _ntripSettings; }
 
GPSCorrectionSettings* SettingsManager::gpsCorrectionSettings() const
{
    return _gpsCorrectionSettings;
}
 
VideoSettings *SettingsManager::videoSettings() const { return _videoSettings; }
MavlinkSettings *SettingsManager::mavlinkSettings() const { return _mavlinkSettings; }
JoystickManagerSettings *SettingsManager::joystickManagerSettings() const { return _joystickManagerSettings; }
LogManagerSettings *SettingsManager::logManagerSettings() const { return _logManagerSettings; }
LogViewerSettings *SettingsManager::logViewerSettings() const { return _logViewerSettings; }
Viewer3DSettings *SettingsManager::viewer3DSettings() const { return _viewer3DSettings; }
 
void SettingsManager::_loadSettingsFiles()
{
    // Settings files can be found in the settingsSavePath() directory
    // Settings files are json files which end in the settingsFileExtension extension
    // The format for a settings file is:
    // {
    //      "version": 1,
    //      "fileType": "Settings",
    //      "groups": {
    //          "groupName": {
    //              "settingName": {
    //                  "forceRawValue": <value>, // Forces the rawValue for this setting to the specific value
    //                  any FactMetaData json keys except for name and type,
    //                  ...
    //          },
    //          "groupName": {
    //              ...
    //          }
    //      }
    // }
 
    QDir settingsDir(_appSettings->settingsSavePath());
    if (!settingsDir.exists()) {
        qCWarning(SettingsManagerLog) << "Settings directory does not exist:" << settingsDir.absolutePath();
        return;
    }
 
    QStringList settingsFiles = settingsDir.entryList(QStringList() << QString("*.%1").arg(_appSettings->settingsFileExtension), QDir::Files);
    for (const QString &fileName : settingsFiles) {
        QFileInfo fileInfo(settingsDir, fileName);
        if (!fileInfo.isFile()) continue;
 
        // Load the settings file
        qCDebug(SettingsManagerLog) << "Loading settings file:" << fileInfo.absoluteFilePath();
 
        QJsonDocument jsonDoc;
        QString errorString;
        if (!JsonParsing::isJsonFile(fileInfo.absoluteFilePath(), jsonDoc, errorString)) {
            qCWarning(SettingsManagerLog) << "Failed to load settings file:" << fileInfo.absoluteFilePath() << errorString;
            continue;
        }
 
        QJsonObject jsonObject = jsonDoc.object();
 
        // Validate the settings file
        int version;
        if (!JsonParsing::validateInternalQGCJsonFile(jsonObject, "Settings", 1, 1, version, errorString)) {
            qCWarning(SettingsManagerLog) << "Settings file failed validation:" << fileInfo.absoluteFilePath() << errorString;
            continue;
        }
 
        // Validate the remainder of the file
 
        // groups key is an object
        static const QList<JsonParsing::KeyValidateInfo> keyInfoList = {
            { kJsonGroupsObjectKey, QJsonValue::Object, true },
        };
        if (!JsonParsing::validateKeys(jsonObject, keyInfoList, errorString)) {
            qCWarning(SettingsManagerLog) << "Settings file incorrect format:" << fileInfo.absoluteFilePath() << errorString;
            continue;
        }
 
        auto groupsObject = jsonObject[kJsonGroupsObjectKey].toObject();
        for (const QString &groupName : groupsObject.keys()) {
            qCDebug(SettingsManagerLog) << "  Loading settings group:" << groupName;
 
            const QJsonValue &groupValue = groupsObject[groupName];
            if (!groupValue.isObject()) {
                qCWarning(SettingsManagerLog) << "Settings file incorrect format, group is not an object:" << fileInfo.absoluteFilePath()
                                            << groupName;
                continue;
            }
 
            auto groupObject = groupValue.toObject();
            for (const QString &settingName : groupObject.keys()) {
                qCDebug(SettingsManagerLog) << "  Loading settings:" << groupName << settingName;
 
                if (!groupObject[settingName].isObject()) {
                    qCWarning(SettingsManagerLog) << "Settings file incorrect format, setting is not an object:" << fileInfo.absoluteFilePath()
                                                << groupName << settingName;
                    continue;
                }
 
                // Store the setting overrides. Note that last one wins if there are multiple settings files with the same setting.
                QJsonObject metaDataObject = groupObject[settingName].toObject();
                _settingsFileOverrides[groupName][settingName] = metaDataObject;
            }
        }
    }
}
 
void SettingsManager::adjustSettingMetaData(const QString &settingsGroup, FactMetaData &metaData, bool &userVisible)
{
    userVisible = true; // By default all settings are visible
 
    SettingsManager *settingsManager = SettingsManager::instance();
    if (!settingsManager) {
        qCWarning(SettingsManagerLog) << "SettingsManager instance not available";
        return;
    }
 
    if (!QGC::runningUnitTests()) {
        // Apply settings file overrides
        const auto &groupOverrides = settingsManager->_settingsFileOverrides;
        if (groupOverrides.contains(settingsGroup) && groupOverrides[settingsGroup].contains(metaData.name())) {
            QJsonObject settingOverrideJsonObject = groupOverrides[settingsGroup][metaData.name()];
 
            // We need to stuff in name and type so settingOverrideJsonObject can parse properly
            settingOverrideJsonObject["name"] = metaData.name();
            settingOverrideJsonObject["type"] = FactMetaData::typeToString(metaData.type());
 
            qCDebug(SettingsManagerLog) << "Applying settings file override for" << settingsGroup << metaData.name();
 
            // Strip SettingsManager-level keys which are not valid Fact metadata keys. Otherwise strict key
            // validation in createFromJsonObject fails and returns default metadata, corrupting the overrides below.
            QJsonObject factMetaDataJsonObject = settingOverrideJsonObject;
            factMetaDataJsonObject.remove(kJsonVisibleKey);
            factMetaDataJsonObject.remove(kJsonForceRawValueKey);
 
            QScopedPointer<FactMetaData> overrideMetaData(FactMetaData::createFromJsonObject(factMetaDataJsonObject, {}, nullptr));
 
            if (settingOverrideJsonObject.contains(kJsonForceRawValueKey) && settingOverrideJsonObject.contains(kJsonVisibleKey)) {
                // A visible setting reads its value from QSettings which defeats forceRawValue
                qCWarning(SettingsManagerLog) << "Ignoring settings file override which combines 'forceRawValue' and 'visible' keys:" << settingsGroup << metaData.name();
            } else if (overrideMetaData->name() != metaData.name()) {
                // createFromJsonObject failed validation (it already logged why) and returned default metadata.
                // Don't apply any part of a bad override.
                qCWarning(SettingsManagerLog) << "Ignoring settings file override which failed validation:" << settingsGroup << metaData.name();
            } else {
                // Apply Fact metadata overrides
                for (const QString &metaDataName : factMetaDataJsonObject.keys()) {
                    if (metaDataName == FactMetaData::_defaultValueJsonKey) {
                        qCDebug(SettingsManagerLog) << "  Setting default to" << overrideMetaData->rawDefaultValue();
                        metaData.setRawDefaultValue(overrideMetaData->rawDefaultValue());
                    } else if (metaDataName == FactMetaData::_minJsonKey) {
                        qCDebug(SettingsManagerLog) << "  Setting min to" << overrideMetaData->rawMin();
                        metaData.setRawMin(overrideMetaData->rawMin());
                    } else if (metaDataName == FactMetaData::_maxJsonKey) {
                        qCDebug(SettingsManagerLog) << "  Setting max to" << overrideMetaData->rawMax();
                        metaData.setRawMax(overrideMetaData->rawMax());
                    } else if (metaDataName == FactMetaData::_decimalPlacesJsonKey) {
                        qCDebug(SettingsManagerLog) << "  Setting decimalPlaces to" << overrideMetaData->decimalPlaces();
                        metaData.setDecimalPlaces(overrideMetaData->decimalPlaces());
                    } else if (metaDataName == FactMetaData::_enumValuesJsonKey) {
                        qCDebug(SettingsManagerLog) << "  Setting enumInfo to" << overrideMetaData->enumValues() << overrideMetaData->enumStrings();
                        metaData.setEnumInfo(overrideMetaData->enumStrings(), overrideMetaData->enumValues());
                    } else if (metaDataName == FactMetaData::_enumBitmaskArrayJsonKey) {
                        qCDebug(SettingsManagerLog) << "  Setting bitmaskInfo to" << overrideMetaData->bitmaskValues() << overrideMetaData->bitmaskStrings();
                        metaData.setBitmaskInfo(overrideMetaData->bitmaskStrings(), overrideMetaData->bitmaskValues());
                    } else if (metaDataName == FactMetaData::_longDescriptionJsonKey) {
                        qCDebug(SettingsManagerLog) << "  Setting longDesc to" << overrideMetaData->longDescription();
                        metaData.setLongDescription(overrideMetaData->longDescription());
                    } else if (metaDataName == FactMetaData::_shortDescriptionJsonKey) {
                        qCDebug(SettingsManagerLog) << "  Setting shortDesc to" << overrideMetaData->shortDescription();
                        metaData.setShortDescription(overrideMetaData->shortDescription());
                    }
                }
 
                // Apply SettingsManager-level overrides last so forceRawValue wins over a default override
                if (settingOverrideJsonObject.contains(kJsonForceRawValueKey)) {
                    qCDebug(SettingsManagerLog) << "  Setting forceRawValue to" << settingOverrideJsonObject[kJsonForceRawValueKey];
                    metaData.setRawDefaultValue(settingOverrideJsonObject[kJsonForceRawValueKey].toVariant());
                    userVisible = false;
                }
                if (settingOverrideJsonObject.contains(kJsonVisibleKey)) {
                    qCDebug(SettingsManagerLog) << "  Setting visibility to" << settingOverrideJsonObject[kJsonVisibleKey].toBool();
                    userVisible = settingOverrideJsonObject[kJsonVisibleKey].toBool();
                }
            }
        }
    }
 
    // Give QGCCorePlugin a whack at it too
    QGCCorePlugin::instance()->adjustSettingMetaData(settingsGroup, metaData, userVisible);
}