feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

McuSupport: Extract settings handling to a class

Browse Source 
Change-Id: I671098f14d7bc13255dc130a4de1ab97d5bdab94
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
This commit is contained in:
Piotr Mućko
2022-04-22 11:41:33 +02:00
parent e675bb7860
commit 7cef593ec0
24 changed files with 529 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/plugins/mcusupport/CMakeLists.txt
View File

@@ -20,6 +20,7 @@ add_qtc_plugin(McuSupport
mcusupportversiondetection.cpp mcusupportversiondetection.h
mcutargetdescription.h
mcuhelpers.cpp mcuhelpers.h
settingshandler.cpp settingshandler.h
)
add_subdirectory(test)

29
src/plugins/mcusupport/mcukitmanager.cpp
View File

@@ -447,11 +447,11 @@ QList<Kit *> outdatedKits()
}
// Maintenance
void createAutomaticKits()
void createAutomaticKits(const SettingsHandler::Ptr &settingsHandler)
{
McuPackagePtr qtForMCUsPackage{Sdk::createQtForMCUsPackage()};
McuPackagePtr qtForMCUsPackage{Sdk::createQtForMCUsPackage(settingsHandler)};
const auto createKits = [qtForMCUsPackage]() {
const auto createKits = [qtForMCUsPackage, settingsHandler]() {
if (McuSupportOptions::automaticKitCreationFromSettings()) {
qtForMCUsPackage->updateStatus();
if (!qtForMCUsPackage->isValidStatus()) {
@@ -494,7 +494,7 @@ void createAutomaticKits()
}
FilePath dir = qtForMCUsPackage->path();
McuSdkRepository repo{Sdk::targetsAndPackages(dir)};
McuSdkRepository repo{Sdk::targetsAndPackages(dir, settingsHandler)};
bool needsUpgrade = false;
for (const auto &target : qAsConst(repo.mcuTargets)) {
@@ -512,7 +512,7 @@ void createAutomaticKits()
}
}
if (needsUpgrade)
McuSupportPlugin::askUserAboutMcuSupportKitsUpgrade();
McuSupportPlugin::askUserAboutMcuSupportKitsUpgrade(settingsHandler);
}
};
@@ -524,15 +524,16 @@ void createAutomaticKits()
// to upgrade, create new kits with current data, for the targets
// for which kits already existed
// function parameter is option to keep the old ones or delete them
void upgradeKitsByCreatingNewPackage(UpgradeOption upgradeOption)
void upgradeKitsByCreatingNewPackage(const SettingsHandler::Ptr &settingsHandler,
UpgradeOption upgradeOption)
{
if (upgradeOption == UpgradeOption::Ignore)
return;
McuPackagePtr qtForMCUsPackage{Sdk::createQtForMCUsPackage()};
McuPackagePtr qtForMCUsPackage{Sdk::createQtForMCUsPackage(settingsHandler)};
auto dir = qtForMCUsPackage->path();
McuSdkRepository repo{Sdk::targetsAndPackages(dir)};
McuSdkRepository repo{Sdk::targetsAndPackages(dir, settingsHandler)};
for (const auto &target : qAsConst(repo.mcuTargets)) {
if (!matchingKits(target.get(), qtForMCUsPackage).empty())
@@ -569,12 +570,12 @@ void upgradeKitInPlace(ProjectExplorer::Kit *kit,
// Maintenance
// If the user changed a path in the McuSupport plugin's UI
// update the corresponding cmake variables in all existing kits
void updatePathsInExistingKits()
void updatePathsInExistingKits(const SettingsHandler::Ptr &settingsHandler)
{
McuPackagePtr qtForMCUsPackage{Sdk::createQtForMCUsPackage()};
McuPackagePtr qtForMCUsPackage{Sdk::createQtForMCUsPackage(settingsHandler)};
FilePath dir = qtForMCUsPackage->path();
McuSdkRepository repo{Sdk::targetsAndPackages(dir)};
McuSdkRepository repo{Sdk::targetsAndPackages(dir, settingsHandler)};
for (const auto &target : qAsConst(repo.mcuTargets)) {
if (target->isValid()) {
for (auto *kit : kitsWithMismatchedDependencies(target.get())) {
@@ -603,7 +604,7 @@ void updatePathsInExistingKits()
// Maintenance
// if we changed minor details in the kits across versions of QtCreator
// this function updates those details in existing older kits
void fixExistingKits()
void fixExistingKits(const SettingsHandler::Ptr &settingsHandler)
{
for (Kit *kit : KitManager::kits()) {
if (!kit->hasValue(Constants::KIT_MCUTARGET_KITVERSION_KEY))
@@ -656,11 +657,11 @@ void fixExistingKits()
}
// Fix kit dependencies for known targets
McuPackagePtr qtForMCUsPackage{Sdk::createQtForMCUsPackage()};
McuPackagePtr qtForMCUsPackage{Sdk::createQtForMCUsPackage(settingsHandler)};
qtForMCUsPackage->updateStatus();
if (qtForMCUsPackage->isValidStatus()) {
FilePath dir = qtForMCUsPackage->path();
McuSdkRepository repo{Sdk::targetsAndPackages(dir)};
McuSdkRepository repo{Sdk::targetsAndPackages(dir, settingsHandler)};
for (const auto &target : qAsConst(repo.mcuTargets))
for (auto kit : existingKits(target.get())) {
if (McuDependenciesKitAspect::dependencies(kit).isEmpty()) {

10
src/plugins/mcusupport/mcukitmanager.h
View File

@@ -26,6 +26,8 @@
#pragma once
#include "mcusupport_global.h"
#include "settingshandler.h"
#include <utils/environmentfwd.h>
#include <QCoreApplication>
@@ -63,15 +65,15 @@ QList<ProjectExplorer::Kit *> kitsWithMismatchedDependencies(const McuTarget *mc
QList<ProjectExplorer::Kit *> outdatedKits();
// Maintenance
void createAutomaticKits();
void upgradeKitsByCreatingNewPackage(UpgradeOption upgradeOption);
void createAutomaticKits(const SettingsHandler::Ptr &);
void upgradeKitsByCreatingNewPackage(const SettingsHandler::Ptr &, UpgradeOption upgradeOption);
void upgradeKitInPlace(ProjectExplorer::Kit *kit,
const McuTarget *mcuTarget,
const McuPackagePtr &qtForMCUsSdk);
// Fixing kits:
void updatePathsInExistingKits();
void fixExistingKits();
void updatePathsInExistingKits(const SettingsHandler::Ptr &);
void fixExistingKits(const SettingsHandler::Ptr &);
// Outdated kits:
void removeOutdatedKits();

26
src/plugins/mcusupport/mcupackage.cpp
View File

@@ -27,6 +27,7 @@
#include "mcusupportconstants.h"
#include "mcusupportsdk.h"
#include "mcusupportversiondetection.h"
#include "settingshandler.h"
#include <baremetal/baremetalconstants.h>
#include <coreplugin/icore.h>
@@ -49,7 +50,8 @@ using namespace Utils;
namespace McuSupport::Internal {
McuPackage::McuPackage(const QString &label,
McuPackage::McuPackage(const SettingsHandler::Ptr &settingsHandler,
const QString &label,
const FilePath &defaultPath,
const FilePath &detectionPath,
const QString &settingsKey,
@@ -59,8 +61,9 @@ McuPackage::McuPackage(const QString &label,
const McuPackageVersionDetector *versionDetector,
const bool addToSystemPath,
const FilePath &relativePathModifier)
: m_label(label)
, m_defaultPath(Sdk::packagePathFromSettings(settingsKey, QSettings::SystemScope, defaultPath))
: settingsHandler(settingsHandler)
, m_label(label)
, m_defaultPath(settingsHandler->getPath(settingsKey, QSettings::SystemScope, defaultPath))
, m_detectionPath(detectionPath)
, m_settingsKey(settingsKey)
, m_versionDetector(versionDetector)
@@ -70,7 +73,7 @@ McuPackage::McuPackage(const QString &label,
, m_downloadUrl(downloadUrl)
, m_addToSystemPath(addToSystemPath)
{
m_path = Sdk::packagePathFromSettings(settingsKey, QSettings::UserScope, m_defaultPath);
m_path = this->settingsHandler->getPath(settingsKey, QSettings::UserScope, m_defaultPath);
}
QString McuPackage::label() const
@@ -227,14 +230,7 @@ QString McuPackage::statusText() const
bool McuPackage::writeToSettings() const
{
const FilePath savedPath = Sdk::packagePathFromSettings(m_settingsKey,
QSettings::UserScope,
m_defaultPath);
const QString key = QLatin1String(Constants::SETTINGS_GROUP) + '/'
+ QLatin1String(Constants::SETTINGS_KEY_PACKAGE_PREFIX) + m_settingsKey;
Core::ICore::settings()->setValueWithDefault(key, m_path.toString(), m_defaultPath.toString());
return savedPath != m_path;
return settingsHandler->write(m_settingsKey, m_path, m_defaultPath);
}
QWidget *McuPackage::widget()
@@ -277,7 +273,8 @@ QWidget *McuPackage::widget()
return widget;
}
McuToolChainPackage::McuToolChainPackage(const QString &label,
McuToolChainPackage::McuToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
const QString &label,
const FilePath &defaultPath,
const FilePath &detectionPath,
const QString &settingsKey,
@@ -285,7 +282,8 @@ McuToolChainPackage::McuToolChainPackage(const QString &label,
const QString &cmakeVarName,
const QString &envVarName,
const McuPackageVersionDetector *versionDetector)
: McuPackage(label,
: McuPackage(settingsHandler,
label,
defaultPath,
detectionPath,
settingsKey,

9
src/plugins/mcusupport/mcupackage.h
View File

@@ -26,6 +26,7 @@
#pragma once
#include "mcuabstractpackage.h"
#include "settingshandler.h"
#include <utils/filepath.h>
@@ -53,7 +54,8 @@ class McuPackage : public McuAbstractPackage
Q_OBJECT
public:
McuPackage(const QString &label,
McuPackage(const SettingsHandler::Ptr &settingsHandler,
const QString &label,
const Utils::FilePath &defaultPath,
const Utils::FilePath &detectionPath,
const QString &settingsKey,
@@ -91,6 +93,8 @@ private:
void updatePath();
void updateStatusUi();
SettingsHandler::Ptr settingsHandler;
Utils::PathChooser *m_fileChooser = nullptr;
Utils::InfoLabel *m_infoLabel = nullptr;
@@ -118,7 +122,8 @@ class McuToolChainPackage : public McuPackage
public:
enum class ToolChainType { IAR, KEIL, MSVC, GCC, ArmGcc, GHS, GHSArm, Unsupported };
McuToolChainPackage(const QString &label,
McuToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
const QString &label,
const Utils::FilePath &defaultPath,
const Utils::FilePath &detectionPath,
const QString &settingsKey,

3
src/plugins/mcusupport/mcusupport.qbs
View File

@@ -51,6 +51,8 @@ QtcPlugin {
"mcukitinformation.h",
"mcuhelpers.cpp",
"mcuhelpers.h",
"settingshandler.h",
"settingshandler.cpp",
]
Group {
@@ -59,6 +61,7 @@ QtcPlugin {
prefix: "test/"
files: [
"packagemock.h",
"settingshandlermock.h",
"unittest.cpp", "unittest.h"
]
}

24
src/plugins/mcusupport/mcusupportoptions.cpp
View File

@@ -32,6 +32,7 @@
#include "mcusupportplugin.h"
#include "mcusupportsdk.h"
#include "mcutarget.h"
#include "settingshandler.h"
#include <cmakeprojectmanager/cmakekitinformation.h>
#include <cmakeprojectmanager/cmaketoolmanager.h>
@@ -56,9 +57,10 @@ const QString automaticKitCreationSettingsKey = QLatin1String(Constants::SETTING
Constants::SETTINGS_KEY_AUTOMATIC_KIT_CREATION);
}
McuSupportOptions::McuSupportOptions(QObject *parent)
McuSupportOptions::McuSupportOptions(const SettingsHandler::Ptr &settingsHandler, QObject *parent)
: QObject(parent)
, qtForMCUsSdkPackage(Sdk::createQtForMCUsPackage())
, qtForMCUsSdkPackage(Sdk::createQtForMCUsPackage(settingsHandler))
, settingsHandler(settingsHandler)
{
connect(qtForMCUsSdkPackage.get(),
&McuAbstractPackage::changed,
@@ -72,9 +74,9 @@ void McuSupportOptions::populatePackagesAndTargets()
setQulDir(qtForMCUsSdkPackage->path());
}
static FilePath qulDocsDir()
FilePath McuSupportOptions::qulDocsDir() const
{
const FilePath qulDir = McuSupportOptions::qulDirFromSettings();
const FilePath qulDir = qulDirFromSettings();
if (qulDir.isEmpty() || !qulDir.exists())
return {};
const FilePath docsDir = qulDir / "docs";
@@ -102,7 +104,7 @@ void McuSupportOptions::registerExamples()
auto examples = {std::make_pair(QStringLiteral("demos"), tr("Qt for MCUs Demos")),
std::make_pair(QStringLiteral("examples"), tr("Qt for MCUs Examples"))};
for (const auto &dir : examples) {
const FilePath examplesDir = McuSupportOptions::qulDirFromSettings().pathAppended(dir.first);
const FilePath examplesDir = qulDirFromSettings() / dir.first;
if (!examplesDir.exists())
continue;
@@ -126,7 +128,7 @@ void McuSupportOptions::setQulDir(const FilePath &dir)
{
qtForMCUsSdkPackage->updateStatus();
if (qtForMCUsSdkPackage->isValidStatus())
sdkRepository = Sdk::targetsAndPackages(dir);
sdkRepository = Sdk::targetsAndPackages(dir, settingsHandler);
else
sdkRepository = McuSdkRepository{};
for (const auto &package : qAsConst(sdkRepository.packages))
@@ -138,11 +140,11 @@ void McuSupportOptions::setQulDir(const FilePath &dir)
emit packagesChanged();
}
FilePath McuSupportOptions::qulDirFromSettings()
FilePath McuSupportOptions::qulDirFromSettings() const
{
return Sdk::packagePathFromSettings(Constants::SETTINGS_KEY_PACKAGE_QT_FOR_MCUS_SDK,
QSettings::UserScope,
{});
return settingsHandler->getPath(Constants::SETTINGS_KEY_PACKAGE_QT_FOR_MCUS_SDK,
QSettings::UserScope,
{});
}
McuKitManager::UpgradeOption McuSupportOptions::askForKitUpgrades()
@@ -175,7 +177,7 @@ void McuSupportOptions::checkUpgradeableKits()
return !McuKitManager::upgradeableKits(target.get(), this->qtForMCUsSdkPackage).empty()
&& McuKitManager::matchingKits(target.get(), this->qtForMCUsSdkPackage).empty();
}))
McuKitManager::upgradeKitsByCreatingNewPackage(askForKitUpgrades());
McuKitManager::upgradeKitsByCreatingNewPackage(settingsHandler, askForKitUpgrades());
}
bool McuSupportOptions::kitsNeedQtVersion()

12
src/plugins/mcusupport/mcusupportoptions.h
View File

@@ -27,6 +27,7 @@
#include "mcukitmanager.h"
#include "mcusupport_global.h"
#include "settingshandler.h"
#include <utils/environmentfwd.h>
@@ -63,17 +64,18 @@ class McuSupportOptions final : public QObject
Q_OBJECT
public:
explicit McuSupportOptions(QObject *parent = nullptr);
explicit McuSupportOptions(const SettingsHandler::Ptr &, QObject *parent = nullptr);
McuPackagePtr qtForMCUsSdkPackage{nullptr};
McuSdkRepository sdkRepository;
void setQulDir(const Utils::FilePath &dir);
static Utils::FilePath qulDirFromSettings();
Utils::FilePath qulDirFromSettings() const;
Utils::FilePath qulDocsDir() const;
static McuKitManager::UpgradeOption askForKitUpgrades();
static void registerQchFiles();
static void registerExamples();
void registerQchFiles();
void registerExamples();
static const QVersionNumber &minimalQulVersion();
static bool isLegacyVersion(const QVersionNumber &version);
@@ -89,6 +91,8 @@ public:
static bool automaticKitCreationFromSettings();
private:
SettingsHandler::Ptr settingsHandler;
bool m_automaticKitCreation = true;
signals:
void packagesChanged();

22
src/plugins/mcusupport/mcusupportoptionspage.cpp
View File

@@ -30,6 +30,7 @@
#include "mcusupportoptions.h"
#include "mcusupportsdk.h"
#include "mcutarget.h"
#include "settingshandler.h"
#include <cmakeprojectmanager/cmakeprojectconstants.h>
#include <cmakeprojectmanager/cmaketoolmanager.h>
@@ -58,7 +59,7 @@ class McuSupportOptionsWidget : public Core::IOptionsPageWidget
Q_DECLARE_TR_FUNCTIONS(McuSupport::Internal::McuSupportOptionsWidget)
public:
McuSupportOptionsWidget();
McuSupportOptionsWidget(McuSupportOptions &, const SettingsHandler::Ptr &);
void updateStatus();
void showMcuTargetPackages();
@@ -71,7 +72,8 @@ private:
void showEvent(QShowEvent *event) final;
QString m_armGccPath;
McuSupportOptions m_options;
McuSupportOptions &m_options;
SettingsHandler::Ptr m_settingsHandler;
QMap<McuPackagePtr, QWidget *> m_packageWidgets;
QMap<McuTargetPtr, QWidget *> m_mcuTargetPacketWidgets;
QFormLayout *m_packagesLayout = nullptr;
@@ -88,7 +90,10 @@ private:
QPushButton *m_kitUpdatePushButton = nullptr;
};
McuSupportOptionsWidget::McuSupportOptionsWidget()
McuSupportOptionsWidget::McuSupportOptionsWidget(McuSupportOptions &options,
const SettingsHandler::Ptr &settingsHandler)
: m_options{options}
, m_settingsHandler(settingsHandler)
{
auto mainLayout = new QVBoxLayout(this);
@@ -161,7 +166,7 @@ McuSupportOptionsWidget::McuSupportOptionsWidget()
m_kitCreationPushButton->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred);
connect(m_kitCreationPushButton, &QPushButton::clicked, this, [this] {
McuKitManager::newKit(currentMcuTarget().get(), m_options.qtForMCUsSdkPackage);
McuSupportOptions::registerQchFiles();
m_options.registerQchFiles();
updateStatus();
});
m_kitUpdatePushButton = new QPushButton(tr("Update Kit"));
@@ -311,7 +316,7 @@ void McuSupportOptionsWidget::apply()
if (pathsChanged) {
m_options.checkUpgradeableKits();
McuKitManager::updatePathsInExistingKits();
McuKitManager::updatePathsInExistingKits(m_settingsHandler);
}
}
@@ -326,12 +331,15 @@ void McuSupportOptionsWidget::populateMcuTargetsComboBox()
updateStatus();
}
McuSupportOptionsPage::McuSupportOptionsPage()
McuSupportOptionsPage::McuSupportOptionsPage(McuSupportOptions &options,
const SettingsHandler::Ptr &settingsHandler)
{
setId(Utils::Id(Constants::SETTINGS_ID));
setDisplayName(McuSupportOptionsWidget::tr("MCU"));
setCategory(ProjectExplorer::Constants::DEVICE_SETTINGS_CATEGORY);
setWidgetCreator([] { return new McuSupportOptionsWidget; });
setWidgetCreator([&options, &settingsHandler] {
return new McuSupportOptionsWidget(options, settingsHandler);
});
}
} // namespace McuSupport::Internal

6
src/plugins/mcusupport/mcusupportoptionspage.h
View File

@@ -25,15 +25,19 @@
#pragma once
#include "settingshandler.h"
#include <coreplugin/dialogs/ioptionspage.h>
namespace McuSupport {
namespace Internal {
class McuSupportOptions;
class McuSupportOptionsPage final : public Core::IOptionsPage
{
public:
McuSupportOptionsPage();
McuSupportOptionsPage(McuSupportOptions &, const SettingsHandler::Ptr &);
};
} // namespace Internal

31
src/plugins/mcusupport/mcusupportplugin.cpp
View File

@@ -72,12 +72,17 @@ void printMessage(const QString &message, bool important)
class McuSupportPluginPrivate
{
public:
explicit McuSupportPluginPrivate(const SettingsHandler::Ptr &settingsHandler)
: m_settingsHandler(settingsHandler)
{}
McuSupportDeviceFactory deviceFactory;
McuSupportRunConfigurationFactory runConfigurationFactory;
RunWorkerFactory runWorkerFactory{makeFlashAndRunWorker(),
{ProjectExplorer::Constants::NORMAL_RUN_MODE},
{Constants::RUNCONFIGURATION}};
McuSupportOptionsPage optionsPage;
SettingsHandler::Ptr m_settingsHandler;
McuSupportOptions m_options{m_settingsHandler};
McuSupportOptionsPage optionsPage{m_options, m_settingsHandler};
McuDependenciesKitAspect environmentPathsKitAspect;
}; // class McuSupportPluginPrivate
@@ -95,10 +100,10 @@ bool McuSupportPlugin::initialize(const QStringList &arguments, QString *errorSt
Q_UNUSED(errorString)
setObjectName("McuSupportPlugin");
dd = new McuSupportPluginPrivate;
dd = new McuSupportPluginPrivate(m_settingsHandler);
McuSupportOptions::registerQchFiles();
McuSupportOptions::registerExamples();
dd->m_options.registerQchFiles();
dd->m_options.registerExamples();
ProjectExplorer::JsonWizardFactory::addWizardPath(":/mcusupport/wizards/");
return true;
@@ -108,18 +113,18 @@ void McuSupportPlugin::extensionsInitialized()
{
ProjectExplorer::DeviceManager::instance()->addDevice(McuSupportDevice::create());
connect(KitManager::instance(), &KitManager::kitsLoaded, []() {
connect(KitManager::instance(), &KitManager::kitsLoaded, [this]() {
McuKitManager::removeOutdatedKits();
McuKitManager::createAutomaticKits();
McuKitManager::fixExistingKits();
McuSupportPlugin::askUserAboutMcuSupportKitsSetup();
McuKitManager::createAutomaticKits(m_settingsHandler);
McuKitManager::fixExistingKits(m_settingsHandler);
askUserAboutMcuSupportKitsSetup();
});
}
void McuSupportPlugin::askUserAboutMcuSupportKitsSetup()
{
if (!ICore::infoBar()->canInfoBeAdded(setupMcuSupportKits)
|| McuSupportOptions::qulDirFromSettings().isEmpty()
|| dd->m_options.qulDirFromSettings().isEmpty()
|| !McuKitManager::existingKits(nullptr).isEmpty())
return;
@@ -135,7 +140,7 @@ void McuSupportPlugin::askUserAboutMcuSupportKitsSetup()
ICore::infoBar()->addInfo(info);
}
void McuSupportPlugin::askUserAboutMcuSupportKitsUpgrade()
void McuSupportPlugin::askUserAboutMcuSupportKitsUpgrade(const SettingsHandler::Ptr &settingsHandler)
{
const char upgradeMcuSupportKits[] = "UpgradeMcuSupportKits";
@@ -156,10 +161,10 @@ void McuSupportPlugin::askUserAboutMcuSupportKitsUpgrade()
selectedOption = selected.data.value<UpgradeOption>();
});
info.addCustomButton(tr("Proceed"), [upgradeMcuSupportKits] {
info.addCustomButton(tr("Proceed"), [upgradeMcuSupportKits, settingsHandler] {
ICore::infoBar()->removeInfo(upgradeMcuSupportKits);
QTimer::singleShot(0, []() {
McuKitManager::upgradeKitsByCreatingNewPackage(selectedOption);
QTimer::singleShot(0, [settingsHandler]() {
McuKitManager::upgradeKitsByCreatingNewPackage(settingsHandler, selectedOption);
});
});

6
src/plugins/mcusupport/mcusupportplugin.h
View File

@@ -26,6 +26,7 @@
#pragma once
#include "mcusupport_global.h"
#include "settingshandler.h"
#include <extensionsystem/iplugin.h>
@@ -44,11 +45,12 @@ public:
bool initialize(const QStringList &arguments, QString *errorString) final;
void extensionsInitialized() final;
static void askUserAboutMcuSupportKitsSetup();
static void askUserAboutMcuSupportKitsUpgrade();
void askUserAboutMcuSupportKitsSetup();
static void askUserAboutMcuSupportKitsUpgrade(const SettingsHandler::Ptr &settingsHandler);
private:
QVector<QObject *> createTestObjects() const final;
SettingsHandler::Ptr m_settingsHandler{new SettingsHandler};
}; // class McuSupportPlugin

306
src/plugins/mcusupport/mcusupportsdk.cpp
View File

@@ -76,14 +76,16 @@ static FilePath findInProgramFiles(const QString &folder)
return {};
}
McuAbstractPackage *createQtForMCUsPackage()
McuPackagePtr createQtForMCUsPackage(const SettingsHandler::Ptr &settingsHandler)
{
return new McuPackage(McuPackage::tr("Qt for MCUs SDK"),
FileUtils::homePath(), // defaultPath
FilePath("bin/qmltocpp").withExecutableSuffix(), // detectionPath
Constants::SETTINGS_KEY_PACKAGE_QT_FOR_MCUS_SDK, // settingsKey
QStringLiteral("Qul_ROOT"), // cmakeVarName
QStringLiteral("Qul_DIR")); // envVarName
return McuPackagePtr{
new McuPackage(settingsHandler,
McuPackage::tr("Qt for MCUs SDK"),
FileUtils::homePath(), // defaultPath
FilePath("bin/qmltocpp").withExecutableSuffix(), // detectionPath
Constants::SETTINGS_KEY_PACKAGE_QT_FOR_MCUS_SDK, // settingsKey
QStringLiteral("Qul_ROOT"), // cmakeVarName
QStringLiteral("Qul_DIR"))}; // envVarName
}
static McuPackageVersionDetector *generatePackageVersionDetector(const QString &envVar)
@@ -106,7 +108,8 @@ static McuPackageVersionDetector *generatePackageVersionDetector(const QString &
/// Create the McuPackage by checking the "boardSdk" property in the JSON file for the board.
/// The name of the environment variable pointing to the the SDK for the board will be defined in the "envVar" property
/// inside the "boardSdk".
McuAbstractPackage *createBoardSdkPackage(const McuTargetDescription &desc)
McuPackagePtr createBoardSdkPackage(const SettingsHandler::Ptr &settingsHandler,
const McuTargetDescription &desc)
{
const auto generateSdkName = [](const QString &envVar) {
qsizetype postfixPos = envVar.indexOf("_SDK_PATH");
@@ -134,19 +137,21 @@ McuAbstractPackage *createBoardSdkPackage(const McuTargetDescription &desc)
const auto versionDetector = generatePackageVersionDetector(desc.boardSdk.envVar);
return new McuPackage(sdkName,
defaultPath,
{}, // detection path
desc.boardSdk.envVar, // settings key
"QUL_BOARD_SDK_DIR", // cmake var
desc.boardSdk.envVar, // env var
{}, // download URL
versionDetector);
return McuPackagePtr{new McuPackage(settingsHandler,
sdkName,
defaultPath,
{}, // detection path
desc.boardSdk.envVar, // settings key
"QUL_BOARD_SDK_DIR", // cmake var
desc.boardSdk.envVar, // env var
{}, // download URL
versionDetector)};
}
McuAbstractPackage *createFreeRTOSSourcesPackage(const QString &envVar,
const FilePath &boardSdkDir,
const FilePath &freeRTOSBoardSdkSubDir)
McuPackagePtr createFreeRTOSSourcesPackage(const SettingsHandler::Ptr &settingsHandler,
const QString &envVar,
const FilePath &boardSdkDir,
const FilePath &freeRTOSBoardSdkSubDir)
{
const QString envVarPrefix = removeRtosSuffix(envVar);
@@ -156,31 +161,50 @@ McuAbstractPackage *createFreeRTOSSourcesPackage(const QString &envVar,
else if (!boardSdkDir.isEmpty() && !freeRTOSBoardSdkSubDir.isEmpty())
defaultPath = boardSdkDir / freeRTOSBoardSdkSubDir.toString();
return new McuPackage(QString::fromLatin1("FreeRTOS Sources (%1)").arg(envVarPrefix),
defaultPath,
{}, // detection path
QString{Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(envVarPrefix),
"FREERTOS_DIR", // cmake var
envVar, // env var
"https://freertos.org"); // download url
return McuPackagePtr{
new McuPackage(settingsHandler,
QString::fromLatin1("FreeRTOS Sources (%1)").arg(envVarPrefix),
defaultPath,
{}, // detection path
QString{Constants::SETTINGS_KEY_FREERTOS_PREFIX}.append(envVarPrefix),
"FREERTOS_DIR", // cmake var
envVar, // env var
"https://freertos.org")}; // download url
}
McuToolChainPackage *createUnsupportedToolChainPackage()
McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &settingsHandler)
{
return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::ToolChainType::Unsupported);
return McuPackagePtr{
new McuPackage(settingsHandler, {}, {}, {}, {}, Constants::TOOLCHAIN_FILE_CMAKE_VARIABLE, {})};
}
McuToolChainPackage *createMsvcToolChainPackage()
McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::Ptr &settingsHandler)
{
return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::ToolChainType::MSVC);
return McuToolChainPackagePtr{new McuToolChainPackage(
settingsHandler, {}, {}, {}, {}, McuToolChainPackage::ToolChainType::Unsupported)};
}
McuToolChainPackage *createGccToolChainPackage()
McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &settingsHandler)
{
return new McuToolChainPackage({}, {}, {}, {}, McuToolChainPackage::ToolChainType::GCC);
return McuToolChainPackagePtr{new McuToolChainPackage(settingsHandler,
{},
{},
{},
{},
McuToolChainPackage::ToolChainType::MSVC)};
}
McuToolChainPackage *createArmGccToolchainPackage()
McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &settingsHandler)
{
return McuToolChainPackagePtr{new McuToolChainPackage(settingsHandler,
{},
{},
{},
{},
McuToolChainPackage::ToolChainType::GCC)};
}
McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &settingsHandler)
{
const char envVar[] = "ARMGCC_DIR";
@@ -204,17 +228,19 @@ McuToolChainPackage *createArmGccToolchainPackage()
{"--version"},
"\\b(\\d+\\.\\d+\\.\\d+)\\b");
return new McuToolChainPackage(McuPackage::tr("GNU Arm Embedded Toolchain"),
defaultPath,
detectionPath,
"GNUArmEmbeddedToolchain", // settingsKey
McuToolChainPackage::ToolChainType::ArmGcc, // toolchainType
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector);
return McuToolChainPackagePtr{
new McuToolChainPackage(settingsHandler,
McuPackage::tr("GNU Arm Embedded Toolchain"),
defaultPath,
detectionPath,
"GNUArmEmbeddedToolchain", // settingsKey
McuToolChainPackage::ToolChainType::ArmGcc, // toolchainType
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector)};
}
McuToolChainPackage *createGhsToolchainPackage()
McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &settingsHandler)
{
const char envVar[] = "GHS_COMPILER_DIR";
@@ -225,17 +251,19 @@ McuToolChainPackage *createGhsToolchainPackage()
{"-V"},
"\\bv(\\d+\\.\\d+\\.\\d+)\\b");
return new McuToolChainPackage("Green Hills Compiler",
defaultPath,
FilePath("ccv850").withExecutableSuffix(), // detectionPath
"GHSToolchain", // settingsKey
McuToolChainPackage::ToolChainType::GHS, // toolchainType
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector);
return McuToolChainPackagePtr{
new McuToolChainPackage(settingsHandler,
"Green Hills Compiler",
defaultPath,
FilePath("ccv850").withExecutableSuffix(), // detectionPath
"GHSToolchain", // settingsKey
McuToolChainPackage::ToolChainType::GHS, // toolchainType
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector)};
}
McuToolChainPackage *createGhsArmToolchainPackage()
McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &settingsHandler)
{
const char envVar[] = "GHS_ARM_COMPILER_DIR";
@@ -246,17 +274,19 @@ McuToolChainPackage *createGhsArmToolchainPackage()
{"-V"},
"\\bv(\\d+\\.\\d+\\.\\d+)\\b");
return new McuToolChainPackage("Green Hills Compiler for ARM",
defaultPath,
FilePath("cxarm").withExecutableSuffix(), // detectionPath
"GHSArmToolchain", // settingsKey
McuToolChainPackage::ToolChainType::GHSArm, // toolchainType
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector);
return McuToolChainPackagePtr{
new McuToolChainPackage(settingsHandler,
"Green Hills Compiler for ARM",
defaultPath,
FilePath("cxarm").withExecutableSuffix(), // detectionPath
"GHSArmToolchain", // settingsKey
McuToolChainPackage::ToolChainType::GHSArm, // toolchainType
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector)};
}
McuToolChainPackage *createIarToolChainPackage()
McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &settingsHandler)
{
const char envVar[] = "IAR_ARM_COMPILER_DIR";
@@ -280,17 +310,19 @@ McuToolChainPackage *createIarToolChainPackage()
{"--version"},
"\\bV(\\d+\\.\\d+\\.\\d+)\\.\\d+\\b");
return new McuToolChainPackage("IAR ARM Compiler",
defaultPath,
detectionPath,
"IARToolchain", // settings key
McuToolChainPackage::ToolChainType::IAR, // toolchainType
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector);
return McuToolChainPackagePtr{
new McuToolChainPackage(settingsHandler,
"IAR ARM Compiler",
defaultPath,
detectionPath,
"IARToolchain", // settings key
McuToolChainPackage::ToolChainType::IAR, // toolchainType
Constants::TOOLCHAIN_DIR_CMAKE_VARIABLE, // cmake var
envVar, // env var
versionDetector)};
}
static McuPackage *createStm32CubeProgrammerPackage()
static McuPackagePtr createStm32CubeProgrammerPackage(const SettingsHandler::Ptr &settingsHandler)
{
FilePath defaultPath;
const QString cubePath = "STMicroelectronics/STM32Cube/STM32CubeProgrammer";
@@ -308,22 +340,22 @@ static McuPackage *createStm32CubeProgrammerPackage()
QLatin1String(Utils::HostOsInfo::isWindowsHost() ? "/bin/STM32_Programmer_CLI.exe"
: "/bin/STM32_Programmer.sh"));
auto result
= new McuPackage(McuPackage::tr("STM32CubeProgrammer"),
defaultPath,
detectionPath,
"Stm32CubeProgrammer",
{}, // cmake var
{}, // env var
"https://www.st.com/en/development-tools/stm32cubeprog.html", // download url
nullptr, // version detector
true, // add to path
"/bin" // relative path modifier
);
return result;
return McuPackagePtr{
new McuPackage(settingsHandler,
McuPackage::tr("STM32CubeProgrammer"),
defaultPath,
detectionPath,
"Stm32CubeProgrammer",
{}, // cmake var
{}, // env var
"https://www.st.com/en/development-tools/stm32cubeprog.html", // download url
nullptr, // version detector
true, // add to path
"/bin" // relative path modifier
)};
}
static McuPackage *createMcuXpressoIdePackage()
static McuPackagePtr createMcuXpressoIdePackage(const SettingsHandler::Ptr &settingsHandler)
{
const char envVar[] = "MCUXpressoIDE_PATH";
@@ -346,17 +378,18 @@ static McuPackage *createMcuXpressoIdePackage()
defaultPath = programPath;
}
return new McuPackage("MCUXpresso IDE",
defaultPath,
FilePath("ide/binaries/crt_emu_cm_redlink")
.withExecutableSuffix(), // detection path
"MCUXpressoIDE", // settings key
"MCUXPRESSO_IDE_PATH", // cmake var
envVar,
"https://www.nxp.com/mcuxpresso/ide"); // download url
return McuPackagePtr{new McuPackage(settingsHandler,
"MCUXpresso IDE",
defaultPath,
FilePath("ide/binaries/crt_emu_cm_redlink")
.withExecutableSuffix(), // detection path
"MCUXpressoIDE", // settings key
"MCUXPRESSO_IDE_PATH", // cmake var
envVar,
"https://www.nxp.com/mcuxpresso/ide")}; // download url
}
static McuPackage *createCypressProgrammerPackage()
static McuPackagePtr createCypressProgrammerPackage(const SettingsHandler::Ptr &settingsHandler)
{
const char envVar[] = "CYPRESS_AUTO_FLASH_UTILITY_DIR";
@@ -374,16 +407,16 @@ static McuPackage *createCypressProgrammerPackage()
}
}
auto result = new McuPackage("Cypress Auto Flash Utility",
defaultPath,
FilePath("/bin/openocd").withExecutableSuffix(),
"CypressAutoFlashUtil", // settings key
"INFINEON_AUTO_FLASH_UTILITY_DIR", // cmake var
envVar); // env var
return result;
return McuPackagePtr{new McuPackage(settingsHandler,
"Cypress Auto Flash Utility",
defaultPath,
FilePath("/bin/openocd").withExecutableSuffix(),
"CypressAutoFlashUtil", // settings key
"INFINEON_AUTO_FLASH_UTILITY_DIR", // cmake var
envVar)}; // env var
}
static McuPackage *createRenesasProgrammerPackage()
static McuPackagePtr createRenesasProgrammerPackage(const SettingsHandler::Ptr &settingsHandler)
{
const char envVar[] = "RenesasFlashProgrammer_PATH";
@@ -401,51 +434,56 @@ static McuPackage *createRenesasProgrammerPackage()
}
}
auto result = new McuPackage("Renesas Flash Programmer",
defaultPath,
FilePath("rfp-cli").withExecutableSuffix(),
"RenesasFlashProgrammer", // settings key
"RENESAS_FLASH_PROGRAMMER_PATH", // cmake var
envVar); // env var
return result;
return McuPackagePtr{new McuPackage(settingsHandler,
"Renesas Flash Programmer",
defaultPath,
FilePath("rfp-cli").withExecutableSuffix(),
"RenesasFlashProgrammer", // settings key
"RENESAS_FLASH_PROGRAMMER_PATH", // cmake var
envVar)}; // env var
}
static McuAbstractTargetFactory::Ptr createFactory(bool isLegacy)
static McuAbstractTargetFactory::Ptr createFactory(bool isLegacy,
const SettingsHandler::Ptr &settingsHandler)
{
McuAbstractTargetFactory::Ptr result;
if (isLegacy) {
static const QHash<QString, McuToolChainPackagePtr> tcPkgs = {
{{"armgcc"}, McuToolChainPackagePtr{createArmGccToolchainPackage()}},
{{"greenhills"}, McuToolChainPackagePtr{createGhsToolchainPackage()}},
{{"iar"}, McuToolChainPackagePtr{createIarToolChainPackage()}},
{{"msvc"}, McuToolChainPackagePtr{createMsvcToolChainPackage()}},
{{"gcc"}, McuToolChainPackagePtr{createGccToolChainPackage()}},
{{"arm-greenhills"}, McuToolChainPackagePtr{createGhsArmToolchainPackage()}},
static const QHash<QString, McuToolChainPackagePtr> toolchainCompilers = {
{{"armgcc"}, McuToolChainPackagePtr{createArmGccToolchainPackage(settingsHandler)}},
{{"greenhills"}, McuToolChainPackagePtr{createGhsToolchainPackage(settingsHandler)}},
{{"iar"}, McuToolChainPackagePtr{createIarToolChainPackage(settingsHandler)}},
{{"msvc"}, McuToolChainPackagePtr{createMsvcToolChainPackage(settingsHandler)}},
{{"gcc"}, McuToolChainPackagePtr{createGccToolChainPackage(settingsHandler)}},
{{"arm-greenhills"},
McuToolChainPackagePtr{createGhsArmToolchainPackage(settingsHandler)}},
};
// Note: the vendor name (the key of the hash) is case-sensitive. It has to match the "platformVendor" key in the
// json file.
static const QHash<QString, McuPackagePtr> vendorPkgs = {
{{"ST"}, McuPackagePtr{createStm32CubeProgrammerPackage()}},
{{"NXP"}, McuPackagePtr{createMcuXpressoIdePackage()}},
{{"CYPRESS"}, McuPackagePtr{createCypressProgrammerPackage()}},
{{"RENESAS"}, McuPackagePtr{createRenesasProgrammerPackage()}},
{{"ST"}, McuPackagePtr{createStm32CubeProgrammerPackage(settingsHandler)}},
{{"NXP"}, McuPackagePtr{createMcuXpressoIdePackage(settingsHandler)}},
{{"CYPRESS"}, McuPackagePtr{createCypressProgrammerPackage(settingsHandler)}},
{{"RENESAS"}, McuPackagePtr{createRenesasProgrammerPackage(settingsHandler)}},
};
result = std::make_unique<McuTargetFactoryLegacy>(tcPkgs, vendorPkgs);
result = std::make_unique<McuTargetFactoryLegacy>(toolchainCompilers,
vendorPkgs,
settingsHandler);
} else {
result = std::make_unique<McuTargetFactory>();
result = std::make_unique<McuTargetFactory>(settingsHandler);
}
return result;
}
McuSdkRepository targetsFromDescriptions(const QList<McuTargetDescription> &descriptions,
const SettingsHandler::Ptr &settingsHandler,
bool isLegacy)
{
Targets mcuTargets;
Packages mcuPackages;
McuAbstractTargetFactory::Ptr targetFactory = createFactory(isLegacy);
McuAbstractTargetFactory::Ptr targetFactory = createFactory(isLegacy, settingsHandler);
for (const McuTargetDescription &desc : descriptions) {
auto [targets, packages] = targetFactory->createTargets(desc);
mcuTargets.append(targets);
@@ -587,12 +625,13 @@ bool checkDeprecatedSdkError(const Utils::FilePath &qulDir, QString &message)
return false;
}
McuSdkRepository targetsAndPackages(const Utils::FilePath &dir)
McuSdkRepository targetsAndPackages(const Utils::FilePath &qtForMCUSdkPath,
const SettingsHandler::Ptr &settingsHandler)
{
QList<McuTargetDescription> descriptions;
bool isLegacy{false};
auto descriptionFiles = targetDescriptionFiles(dir);
auto descriptionFiles = targetDescriptionFiles(qtForMCUSdkPath);
for (const QFileInfo &fileInfo : descriptionFiles) {
QFile file(fileInfo.absoluteFilePath());
if (!file.open(QFile::ReadOnly))
@@ -631,20 +670,20 @@ McuSdkRepository targetsAndPackages(const Utils::FilePath &dir)
// No valid description means invalid or old SDK installation.
if (descriptions.empty()) {
if (kitsPath(dir).exists()) {
if (kitsPath(qtForMCUSdkPath).exists()) {
printMessage(McuTarget::tr("No valid kit descriptions found at %1.")
.arg(kitsPath(dir).toUserOutput()),
.arg(kitsPath(qtForMCUSdkPath).toUserOutput()),
true);
return McuSdkRepository{};
} else {
QString deprecationMessage;
if (checkDeprecatedSdkError(dir, deprecationMessage)) {
if (checkDeprecatedSdkError(qtForMCUSdkPath, deprecationMessage)) {
printMessage(deprecationMessage, true);
return McuSdkRepository{};
}
}
}
McuSdkRepository repo = targetsFromDescriptions(descriptions, isLegacy);
McuSdkRepository repo = targetsFromDescriptions(descriptions, settingsHandler, isLegacy);
// Keep targets sorted lexicographically
Utils::sort(repo.mcuTargets, [](const McuTargetPtr &lhs, const McuTargetPtr &rhs) {
@@ -654,17 +693,6 @@ McuSdkRepository targetsAndPackages(const Utils::FilePath &dir)
return repo;
}
FilePath packagePathFromSettings(const QString &settingsKey,
QSettings::Scope scope,
const FilePath &defaultPath)
{
QSettings *settings = Core::ICore::settings(scope);
const QString key = QLatin1String(Constants::SETTINGS_GROUP) + '/'
+ QLatin1String(Constants::SETTINGS_KEY_PACKAGE_PREFIX) + settingsKey;
const QString path = settings->value(key, defaultPath.toString()).toString();
return FilePath::fromUserInput(path);
}
} // namespace Sdk
} // namespace Internal
} // namespace McuSupport

37
src/plugins/mcusupport/mcusupportsdk.h
View File

@@ -26,6 +26,7 @@
#pragma once
#include "mcusupport_global.h"
#include "settingshandler.h"
#include <utils/filepath.h>
@@ -44,33 +45,33 @@ namespace Sdk {
struct McuTargetDescription;
McuAbstractPackage *createQtForMCUsPackage();
McuPackagePtr createQtForMCUsPackage(const SettingsHandler::Ptr &);
bool checkDeprecatedSdkError(const Utils::FilePath &qulDir, QString &message);
McuSdkRepository targetsAndPackages(const Utils::FilePath &qulDir);
McuSdkRepository targetsAndPackages(const Utils::FilePath &qulDir, const SettingsHandler::Ptr &);
McuTargetDescription parseDescriptionJson(const QByteArray &);
McuSdkRepository targetsFromDescriptions(const QList<McuTargetDescription> &, bool isLegacy);
McuSdkRepository targetsFromDescriptions(const QList<McuTargetDescription> &,
const SettingsHandler::Ptr &,
bool isLegacy);
Utils::FilePath kitsPath(const Utils::FilePath &dir);
Utils::FilePath packagePathFromSettings(const QString &settingsKey,
QSettings::Scope scope,
const Utils::FilePath &defaultPath);
McuPackagePtr createUnsupportedToolChainFilePackage(const SettingsHandler::Ptr &);
McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::Ptr &);
McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &);
McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &);
McuToolChainPackagePtr createArmGccToolchainPackage(const SettingsHandler::Ptr &);
McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &);
McuToolChainPackagePtr createGhsToolchainPackage(const SettingsHandler::Ptr &);
McuToolChainPackagePtr createGhsArmToolchainPackage(const SettingsHandler::Ptr &);
McuToolChainPackage *createUnsupportedToolChainPackage();
McuToolChainPackage *createIarToolChainPackage();
McuToolChainPackage *createGccToolChainPackage();
McuToolChainPackage *createArmGccToolchainPackage();
McuToolChainPackage *createMsvcToolChainPackage();
McuToolChainPackage *createGhsToolchainPackage();
McuToolChainPackage *createGhsArmToolchainPackage();
McuAbstractPackage *createBoardSdkPackage(const McuTargetDescription &desc);
McuAbstractPackage *createFreeRTOSSourcesPackage(const QString &envVar,
const Utils::FilePath &boardSdkDir,
const Utils::FilePath &freeRTOSBoardSdkSubDir);
McuPackagePtr createBoardSdkPackage(const SettingsHandler::Ptr &, const McuTargetDescription &);
McuPackagePtr createFreeRTOSSourcesPackage(const SettingsHandler::Ptr &settingsHandler,
const QString &envVar,
const Utils::FilePath &boardSdkDir,
const Utils::FilePath &freeRTOSBoardSdkSubDir);
} // namespace Sdk
} // namespace McuSupport::Internal

8
src/plugins/mcusupport/mcutargetfactory.cpp
View File

@@ -61,6 +61,10 @@ const static QMap<QString, McuToolChainPackage::ToolChainType> toolchainTypeMapp
{"ghsarm", McuToolChainPackage::ToolChainType::GHSArm},
};
McuTargetFactory::McuTargetFactory(const SettingsHandler::Ptr &settingsHandler)
: settingsHandler{settingsHandler}
{}
QPair<Targets, Packages> McuTargetFactory::createTargets(const McuTargetDescription &desc)
{
Targets mcuTargets;
@@ -109,6 +113,7 @@ Packages McuTargetFactory::createPackages(const McuTargetDescription &desc)
McuPackagePtr McuTargetFactory::createPackage(const PackageDescription &pkgDesc)
{
return McuPackagePtr{new McuPackage{
settingsHandler,
pkgDesc.label,
pkgDesc.defaultPath,
pkgDesc.validationPath,
@@ -130,11 +135,12 @@ McuToolChainPackage *McuTargetFactory::createToolchain(
= toolchainTypeMapping.value(toolchain.id, McuToolChainPackage::ToolChainType::Unsupported);
if (isDesktopToolchain(toolchainType))
return new McuToolChainPackage{{}, {}, {}, {}, toolchainType};
return new McuToolChainPackage{settingsHandler, {}, {}, {}, {}, toolchainType};
else if (!isToolchainDescriptionValid(toolchain))
return nullptr;
return new McuToolChainPackage{
settingsHandler,
compilerDescription.label,
compilerDescription.defaultPath,
compilerDescription.validationPath,

13
src/plugins/mcusupport/mcutargetfactory.h
View File

@@ -27,6 +27,7 @@
#include "mcuabstracttargetfactory.h"
#include "mcutargetdescription.h"
#include "settingshandler.h"
namespace McuSupport::Internal::Sdk {
@@ -35,10 +36,14 @@ struct PackageDescription;
class McuTargetFactory : public McuAbstractTargetFactory
{
public:
QPair<Targets, Packages> createTargets(const McuTargetDescription &) override;
Packages createPackages(const McuTargetDescription &);
McuToolChainPackage *createToolchain(const McuTargetDescription::Toolchain &);
McuPackagePtr createPackage(const PackageDescription &);
explicit McuTargetFactory(const SettingsHandler::Ptr &);
QPair<Targets, Packages> createTargets(const Sdk::McuTargetDescription &) override;
Packages createPackages(const Sdk::McuTargetDescription &);
McuToolChainPackage *createToolchain(const Sdk::McuTargetDescription::Toolchain &);
McuPackagePtr createPackage(const Sdk::PackageDescription &);
private:
SettingsHandler::Ptr settingsHandler;
}; // struct McuTargetFactory
} // namespace McuSupport::Internal::Sdk

24
src/plugins/mcusupport/mcutargetfactorylegacy.cpp
View File

@@ -36,6 +36,14 @@
namespace McuSupport::Internal::Sdk {
McuTargetFactoryLegacy::McuTargetFactoryLegacy(const QHash<QString, McuToolChainPackagePtr> &tcPkgs,
const QHash<QString, McuPackagePtr> &vendorPkgs,
const SettingsHandler::Ptr &settingsHandler)
: tcPkgs(tcPkgs)
, vendorPkgs(vendorPkgs)
, settingsHandler(settingsHandler)
{}
QPair<Targets, Packages> McuTargetFactoryLegacy::createTargets(const McuTargetDescription &desc)
{
QHash<QString, McuPackagePtr> boardSdkPkgs;
@@ -46,7 +54,7 @@ QPair<Targets, Packages> McuTargetFactoryLegacy::createTargets(const McuTargetDe
if (tcPkg) {
tcPkg->setVersions(desc.toolchain.versions);
} else {
tcPkg.reset(createUnsupportedToolChainPackage());
tcPkg = createUnsupportedToolChainPackage(settingsHandler);
}
for (int colorDepth : desc.platform.colorDepths) {
Packages required3rdPartyPkgs;
@@ -65,7 +73,7 @@ QPair<Targets, Packages> McuTargetFactoryLegacy::createTargets(const McuTargetDe
Utils::FilePath boardSdkDefaultPath;
if (!desc.boardSdk.envVar.isEmpty()) {
if (!boardSdkPkgs.contains(desc.boardSdk.envVar)) {
McuPackagePtr boardSdkPkg{createBoardSdkPackage(desc)};
McuPackagePtr boardSdkPkg{createBoardSdkPackage(settingsHandler, desc)};
boardSdkPkgs.insert(desc.boardSdk.envVar, boardSdkPkg);
}
McuPackagePtr boardSdkPkg{boardSdkPkgs.value(desc.boardSdk.envVar)};
@@ -77,11 +85,13 @@ QPair<Targets, Packages> McuTargetFactoryLegacy::createTargets(const McuTargetDe
// Free RTOS specific settings.
if (!desc.freeRTOS.envVar.isEmpty()) {
if (!freeRTOSPkgs.contains(desc.freeRTOS.envVar)) {
freeRTOSPkgs.insert(desc.freeRTOS.envVar,
McuPackagePtr{
createFreeRTOSSourcesPackage(desc.freeRTOS.envVar,
boardSdkDefaultPath,
desc.freeRTOS.boardSdkSubDir)});
freeRTOSPkgs
.insert(desc.freeRTOS.envVar,
McuPackagePtr{
Sdk::createFreeRTOSSourcesPackage(settingsHandler,
desc.freeRTOS.envVar,
boardSdkDefaultPath,
desc.freeRTOS.boardSdkSubDir)});
}
required3rdPartyPkgs.insert(freeRTOSPkgs.value(desc.freeRTOS.envVar));
}

10
src/plugins/mcusupport/mcutargetfactorylegacy.h
View File

@@ -26,6 +26,8 @@
#pragma once
#include "mcuabstracttargetfactory.h"
#include "mcutargetdescription.h"
#include "settingshandler.h"
#include <QHash>
#include <QPair>
@@ -36,10 +38,8 @@ class McuTargetFactoryLegacy : public McuAbstractTargetFactory
{
public:
McuTargetFactoryLegacy(const QHash<QString, McuToolChainPackagePtr> &tcPkgs,
const QHash<QString, McuPackagePtr> &vendorPkgs)
: tcPkgs(tcPkgs)
, vendorPkgs(vendorPkgs)
{}
const QHash<QString, McuPackagePtr> &vendorPkgs,
const SettingsHandler::Ptr &);
QPair<Targets, Packages> createTargets(const McuTargetDescription &) override;
AdditionalPackages getAdditionalPackages() const override;
@@ -47,6 +47,8 @@ public:
private:
const QHash<QString, McuToolChainPackagePtr> tcPkgs;
const QHash<QString, McuPackagePtr> vendorPkgs;
SettingsHandler::Ptr settingsHandler;
}; // struct McuTargetFactoryLegacy
} // namespace McuSupport::Internal::Sdk

70
src/plugins/mcusupport/settingshandler.cpp Normal file
View File

@@ -0,0 +1,70 @@
/****************************************************************************
**
** Copyright (C) 2022 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#include "settingshandler.h"
#include "mcusupportconstants.h"
#include "mcusupportsdk.h"
#include <coreplugin/icore.h>
#include <utils/filepath.h>
namespace McuSupport::Internal {
using Utils::FilePath;
static FilePath packagePathFromSettings(const QString &settingsKey,
QSettings &settings,
const FilePath &defaultPath)
{
const QString key = QLatin1String(Constants::SETTINGS_GROUP) + '/'
+ QLatin1String(Constants::SETTINGS_KEY_PACKAGE_PREFIX) + settingsKey;
const QString path = settings.value(key, defaultPath.toUserOutput()).toString();
return FilePath::fromUserInput(path);
}
FilePath SettingsHandler::getPath(const QString &settingsKey,
QSettings::Scope scope,
const Utils::FilePath &defaultPath) const
{
return packagePathFromSettings(settingsKey, *Core::ICore::settings(scope), defaultPath);
}
bool SettingsHandler::write(const QString &settingsKey,
const Utils::FilePath &path,
const Utils::FilePath &defaultPath) const
{
const FilePath savedPath = packagePathFromSettings(settingsKey,
*Core::ICore::settings(QSettings::UserScope),
defaultPath);
const QString key = QLatin1String(Constants::SETTINGS_GROUP) + '/'
+ QLatin1String(Constants::SETTINGS_KEY_PACKAGE_PREFIX) + settingsKey;
Core::ICore::settings()->setValueWithDefault(key,
path.toUserOutput(),
defaultPath.toUserOutput());
return savedPath != path;
}
} // namespace McuSupport::Internal

50
src/plugins/mcusupport/settingshandler.h Normal file
View File

@@ -0,0 +1,50 @@
/****************************************************************************
**
** Copyright (C) 2022 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#pragma once
#include <QSettings>
#include <QSharedPointer>
#include <QString>
namespace Utils {
class FilePath;
} //namespace Utils
namespace McuSupport::Internal {
class SettingsHandler
{
public:
using Ptr = QSharedPointer<SettingsHandler>;
virtual ~SettingsHandler() = default;
virtual Utils::FilePath getPath(const QString &settingsKey,
QSettings::Scope scope,
const Utils::FilePath &m_defaultPath) const;
virtual bool write(const QString &settingsKey,
const Utils::FilePath &path,
const Utils::FilePath &defaultPath) const;
}; //class SettingsHandler
} // namespace McuSupport::Internal

2
src/plugins/mcusupport/test/CMakeLists.txt
View File

@@ -6,7 +6,7 @@ if(TARGET Googletest)
CONDITION WITH_TESTS
DEPENDS Googletest
SOURCES
unittest.h unittest.cpp packagemock.h
unittest.h unittest.cpp packagemock.h settingshandlermock.h
)
else()
message("Googletest target is missing")

48
src/plugins/mcusupport/test/settingshandlermock.h Normal file
View File

@@ -0,0 +1,48 @@
/****************************************************************************
**
** Copyright (C) 2022 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#pragma once
#include "settingshandler.h"
#include <gmock/gmock.h>
#include <utils/filepath.h>
namespace McuSupport::Internal {
class SettingsHandlerMock : public SettingsHandler
{
public:
SettingsHandlerMock() = default;
~SettingsHandlerMock() override = default;
MOCK_METHOD(Utils::FilePath,
getPath,
(const QString &, QSettings::Scope, const Utils::FilePath &),
(const));
MOCK_METHOD(bool,
write,
(const QString &, const Utils::FilePath &, const Utils::FilePath &),
(const));
}; //class SettingsHandler
} // namespace McuSupport::Internal

27
src/plugins/mcusupport/test/unittest.cpp
View File

@@ -143,6 +143,19 @@ void verifyGccToolchain(const McuToolChainPackage *gccPackage)
QCOMPARE(gccPackage->toolchainType(), McuToolChainPackage::ToolChainType::GCC);
}
McuSupportTest::McuSupportTest()
: targetFactory{settingsMockPtr}
, toolchainPackagePtr{
new McuToolChainPackage{settingsMockPtr,
{}, // label
{}, // defaultPath
{}, // detectionPath
{}, // settingsKey
McuToolChainPackage::ToolChainType::Unsupported, // toolchain type
{}, // cmake var name
{}}} // env var name
{}
void McuSupportTest::initTestCase()
{
targetDescription = Sdk::McuTargetDescription{
@@ -269,8 +282,8 @@ void McuSupportTest::test_addFreeRtosCmakeVarToKit()
void McuSupportTest::test_legacy_createIarToolchain()
{
McuToolChainPackage *iarToolchainPackage = Sdk::createIarToolChainPackage();
verifyIarToolchain(iarToolchainPackage);
McuToolChainPackagePtr iarToolchainPackage = Sdk::createIarToolChainPackage(settingsMockPtr);
verifyIarToolchain(iarToolchainPackage.get());
}
void McuSupportTest::test_createIarToolchain()
@@ -283,8 +296,8 @@ void McuSupportTest::test_createIarToolchain()
void McuSupportTest::test_legacy_createDesktopGccToolchain()
{
McuToolChainPackage *gccPackage = Sdk::createGccToolChainPackage();
verifyGccToolchain(gccPackage);
McuToolChainPackagePtr gccPackage = Sdk::createGccToolChainPackage(settingsMockPtr);
verifyGccToolchain(gccPackage.get());
}
void McuSupportTest::test_createDesktopGccToolchain()
@@ -384,7 +397,8 @@ void McuSupportTest::test_createPackagesWithCorrespondingSettings()
{
QFETCH(QString, json);
const Sdk::McuTargetDescription description = Sdk::parseDescriptionJson(json.toLocal8Bit());
const auto [targets, packages]{Sdk::targetsFromDescriptions({description}, runLegacy)};
const auto [targets,
packages]{Sdk::targetsFromDescriptions({description}, settingsMockPtr, runLegacy)};
Q_UNUSED(targets);
QSet<QString> settings = Utils::transform<QSet<QString>>(packages, [](const auto &package) {
@@ -414,7 +428,8 @@ void McuSupportTest::test_createFreeRtosPackageWithCorrectSetting()
QFETCH(QString, freeRtosEnvVar);
QFETCH(QString, expectedSettingsKey);
auto *package{Sdk::createFreeRTOSSourcesPackage(freeRtosEnvVar, FilePath{}, FilePath{})};
McuPackagePtr package{
Sdk::createFreeRTOSSourcesPackage(settingsMockPtr, freeRtosEnvVar, FilePath{}, FilePath{})};
QVERIFY(package != nullptr);
QCOMPARE(package->settingsKey(), expectedSettingsKey);

15
src/plugins/mcusupport/test/unittest.h
View File

@@ -32,6 +32,7 @@
#include "mcutarget.h"
#include "mcutargetfactory.h"
#include "packagemock.h"
#include "settingshandlermock.h"
#include <projectexplorer/kit.h>
#include <projectexplorer/kitinformation.h>
@@ -47,6 +48,8 @@ namespace McuSupport::Internal::Test {
class McuSupportTest : public QObject
{
Q_OBJECT
public:
McuSupportTest();
private slots:
void initTestCase();
@@ -82,16 +85,12 @@ private:
PackageMock *sdkPackage{new PackageMock};
McuPackagePtr freeRtosPackagePtr{freeRtosPackage};
McuPackagePtr sdkPackagePtr{sdkPackage};
SettingsHandlerMock *settingsMock{new SettingsHandlerMock};
QSharedPointer<SettingsHandlerMock> settingsMockPtr{settingsMock};
Sdk::McuTargetFactory targetFactory;
Sdk::McuTargetDescription targetDescription;
McuToolChainPackagePtr toolchainPackagePtr{
new McuToolChainPackage{{}, // label
{}, // defaultPath
{}, // detectionPath
{}, // settingsKey
McuToolChainPackage::ToolChainType::Unsupported, // toolchain type
{}, // cmake var name
{}}}; // env var name
McuToolChainPackagePtr toolchainPackagePtr;
}; // class McuSupportTest
} // namespace McuSupport::Internal::Test