McuSupport: Read supported targets from SDK .json files

... Replace the current hard-coded list of supported (non-Desktop)
targets.

Task-number: UL-2012
Change-Id: I65851d11eea9f62635d56c42788caeae8a77a4f3
Reviewed-by: Eike Ziller <eike.ziller@qt.io>

src/plugins/mcusupport/mcusupportoptions.cpp

@@ -61,7 +61,7 @@
 namespace McuSupport {
 namespace Internal {
 
-static const int KIT_VERSION = 3; // Bumps up whenever details in Kit creation change
+static const int KIT_VERSION = 4; // Bumps up whenever details in Kit creation change
 
 static QString packagePathFromSettings(const QString &settingsKey, const QString &defaultPath = {})
 {
@@ -441,14 +441,14 @@ void McuSupportOptions::deletePackagesAndTargets()
 
 const QVersionNumber &McuSupportOptions::supportedQulVersion()
 {
-    static const QVersionNumber v({1, 1, 0});
+    static const QVersionNumber v({1, 1});
     return v;
 }
 
 void McuSupportOptions::setQulDir(const Utils::FilePath &dir)
 {
     deletePackagesAndTargets();
-    Sdk::hardcodedTargetsAndPackages(dir, &packages, &mcuTargets);
+    Sdk::targetsAndPackages(dir, &packages, &mcuTargets);
     //packages.append(qtForMCUsSdkPackage);
     for (auto package : packages) {
         connect(package, &McuPackage::changed, [this](){

src/plugins/mcusupport/mcusupportsdk.cpp

@@ -27,10 +27,17 @@
 #include "mcusupportoptions.h"
 #include "mcusupportsdk.h"
 
+#include <utils/algorithm.h>
 #include <utils/hostosinfo.h>
 #include <utils/fileutils.h>
 
 #include <QDir>
+#include <QDirIterator>
+#include <QHash>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QVariant>
 
 namespace McuSupport {
 namespace Internal {
@@ -220,9 +227,9 @@ static McuPackage *createMcuXpressoIdePackage()
     return result;
 }
 
-static McuPackage *createFreeRTOSSourcesPackage(const QString &envVarPrefix)
+static McuPackage *createFreeRTOSSourcesPackage(const QString &envVar)
 {
-    const QString envVar = envVarPrefix + "_FREERTOS_DIR";
+    const QString envVarPrefix = envVar.chopped(strlen("_FREERTOS_DIR"));
 
     const QString defaultPath =
             qEnvironmentVariableIsSet(envVar.toLatin1()) ?
@@ -238,98 +245,147 @@ static McuPackage *createFreeRTOSSourcesPackage(const QString &envVarPrefix)
     return result;
 }
 
-void hardcodedTargetsAndPackages(const Utils::FilePath &dir, QVector<McuPackage *> *packages,
+struct McuTargetDescription
-                                 QVector<McuTarget *> *mcuTargets)
 {
-    McuToolChainPackage* armGccPackage = Sdk::createArmGccPackage();
+    QString qulVersion;
-    McuToolChainPackage *ghsToolchainPackage = createGhsToolchainPackage();
+    QString platform;
-    McuToolChainPackage* desktopToolChainPackage = createDesktopToolChainPackage();
+    QString platformVendor;
-    McuPackage* stm32CubeFwF7SdkPackage = Sdk::createStm32CubeFwF7SdkPackage();
+    QVector<int> colorDepths;
-    McuPackage* stm32CubeProgrammerPackage = Sdk::createStm32CubeProgrammerPackage();
+    QString toolchainId;
-    McuPackage* evkbImxrt1050SdkPackage = Sdk::createEvkbImxrt1050SdkPackage();
+    QString boardSdkEnvVar;
-    McuPackage *mcuXpressoIdePackage = createMcuXpressoIdePackage();
+    QString freeRTOSEnvVar;
-    McuPackage *rglPackage = createRGLPackage();
+};
-    McuPackage *freeRTOSSTM32F7Package = createFreeRTOSSourcesPackage("STM32F7");
-    McuPackage *freeRTOSIMXRT1050Package = createFreeRTOSSourcesPackage("IMXRT1050");
-    McuPackage *freeRTOSIMXRT1064Package = createFreeRTOSSourcesPackage("IMXRT1064");
 
-    QVector<McuPackage*> stmEvalPackages = {
+static QVector<McuTarget *> targetsFromDescriptions(const QList<McuTargetDescription> &descriptions,
-        armGccPackage, stm32CubeProgrammerPackage};
+                                                    QVector<McuPackage *> *packages)
-    QVector<McuPackage*> nxpEvalPackages = {
+{
-        armGccPackage, mcuXpressoIdePackage};
+    const QHash<QString, McuToolChainPackage *> tcPkgs = {
-    QVector<McuPackage*> renesasEvalPackages = {
+        {{"armgcc"}, createArmGccPackage()},
-        ghsToolchainPackage, rglPackage};
+        {{"greenhills"}, createGhsToolchainPackage()},
-    QVector<McuPackage*> desktopPackages = {};
+        {{"desktop"}, createDesktopToolChainPackage()},
-    *packages = {
-        armGccPackage, desktopToolChainPackage, ghsToolchainPackage,
-        stm32CubeFwF7SdkPackage, stm32CubeProgrammerPackage, evkbImxrt1050SdkPackage,
-        mcuXpressoIdePackage, rglPackage,
-        freeRTOSSTM32F7Package, freeRTOSIMXRT1050Package, freeRTOSIMXRT1064Package};
-
-    const QString vendorStm = "STM";
-    const QString vendorNxp = "NXP";
-    const QString vendorQt = "Qt";
-    const QString vendorRenesas = "Renesas";
-
-    const struct {
-        const QString &vendor;
-        const QString qulPlatform;
-        const QVector<McuPackage*> &packages;
-        McuToolChainPackage *toolchainPackage;
-        McuPackage *freeRTOSPackage;
-        const QVector<int> colorDepths;
-    } targets[] = {
-        {vendorNxp, {"MIMXRT1050-EVK"}, nxpEvalPackages, armGccPackage,
-                freeRTOSIMXRT1050Package, {16}},
-        {vendorNxp, {"MIMXRT1064-EVK"}, nxpEvalPackages, armGccPackage,
-                freeRTOSIMXRT1064Package, {16}},
-        {vendorQt, {"Qt"}, desktopPackages, desktopToolChainPackage,
-                nullptr, {32}},
-        {vendorRenesas, {"RH850-D1M1A"}, renesasEvalPackages, ghsToolchainPackage,
-                nullptr, {32}},
-        {vendorStm, {"STM32F469I-DISCOVERY"}, stmEvalPackages, armGccPackage,
-                nullptr, {24}},
-        {vendorStm, {"STM32F7508-DISCOVERY"}, stmEvalPackages, armGccPackage,
-                freeRTOSSTM32F7Package, {32, 16}},
-        {vendorStm, {"STM32F769I-DISCOVERY"}, stmEvalPackages, armGccPackage,
-                freeRTOSSTM32F7Package, {32}},
-        {vendorStm, {"STM32H750B-DISCOVERY"}, stmEvalPackages, armGccPackage,
-                nullptr, {32}},
-        {vendorStm, {"STM32L4R9I-DISCOVERY"}, stmEvalPackages, armGccPackage,
-                nullptr, {24}},
-        {vendorStm, {"STM32L4R9I-EVAL"}, stmEvalPackages, armGccPackage,
-                nullptr, {24}}
     };
 
-    const QString QulTargetTemplate =
+    const QHash<QString, McuPackage *> vendorPkgs = {
-            dir.toString() + "/lib/cmake/Qul/QulTargets/QulTargets_%1_%2.cmake";
+        {{"ST"}, createStm32CubeProgrammerPackage()},
-    for (const auto target : targets) {
+        {{"NXP"}, createMcuXpressoIdePackage()},
-        for (auto os : {McuTarget::OS::Desktop, McuTarget::OS::BareMetal,
+        {{"Renesas"}, createRGLPackage()}
-                        McuTarget::OS::FreeRTOS}) {
+    };
-            for (int colorDepth : target.colorDepths) {
+
-                QVector<McuPackage*> required3rdPartyPackages = target.packages;
+    QHash<QString, McuPackage *> freeRTOSPkgs;
+    QVector<McuTarget *> mcuTargets;
+
+    for (auto desc : descriptions) {
+        McuToolChainPackage *tcPkg = tcPkgs.value(desc.toolchainId);
+        if (desc.toolchainId == "desktop") {
+            auto mcuTarget = new McuTarget(desc.platformVendor, desc.platform,
+                                           McuTarget::OS::Desktop, {}, tcPkg);
+            mcuTargets.append(mcuTarget);
+            continue;
+        }
+        for (auto os : {McuTarget::OS::BareMetal, McuTarget::OS::FreeRTOS}) {
+            for (int colorDepth : desc.colorDepths) {
+                QVector<McuPackage*> required3rdPartyPkgs = {
+                    vendorPkgs.value(desc.platformVendor), tcPkg
+                };
                 if (os == McuTarget::OS::FreeRTOS) {
-                    if (target.freeRTOSPackage)
+                    if (desc.freeRTOSEnvVar.isEmpty()) {
-                        required3rdPartyPackages.append(target.freeRTOSPackage);
-                    else
                         continue;
-                } else if (os == McuTarget::OS::Desktop && target.toolchainPackage->type()
+                    } else {
-                        != McuToolChainPackage::TypeDesktop) {
+                        if (!freeRTOSPkgs.contains(desc.freeRTOSEnvVar)) {
-                    continue;
+                            auto freeRTOSPkg = createFreeRTOSSourcesPackage(desc.freeRTOSEnvVar);
+                            freeRTOSPkgs.insert(desc.freeRTOSEnvVar, freeRTOSPkg);
+                        }
+                        required3rdPartyPkgs.append(freeRTOSPkgs.value(desc.freeRTOSEnvVar));
+                    }
                 }
 
-                const QString QulTarget =
+                auto mcuTarget = new McuTarget(desc.platformVendor, desc.platform, os,
-                        QulTargetTemplate.arg(target.qulPlatform, QString::number(colorDepth));
+                                               required3rdPartyPkgs, tcPkg);
-                if (!Utils::FilePath::fromUserInput(QulTarget).exists())
+                if (desc.colorDepths.count() > 1)
-                    continue;
-                auto mcuTarget = new McuTarget(target.vendor, target.qulPlatform, os,
-                                               required3rdPartyPackages, target.toolchainPackage);
-                if (target.colorDepths.count() > 1)
                     mcuTarget->setColorDepth(colorDepth);
-                mcuTargets->append(mcuTarget);
+                mcuTargets.append(mcuTarget);
             }
         }
     }
+
+    packages->append(Utils::transform<QVector<McuPackage *> >(
+                         tcPkgs.values(), [&](McuToolChainPackage *tcPkg) { return tcPkg; }));
+    packages->append(vendorPkgs.values().toVector());
+    packages->append(freeRTOSPkgs.values().toVector());
+
+    return  mcuTargets;
+}
+
+static QFileInfoList targetDescriptionFiles(const Utils::FilePath &dir)
+{
+    // Workaround for UL-2390: Instead of "./kits/", walk through "./lib/cmake/Qul/boards/"
+    QFileInfoList result;
+    QDirIterator it(dir.toString() + "/lib/cmake/Qul/boards/", {QLatin1String("*.json")},
+                    QDir::Files, QDirIterator::Subdirectories);
+    while (it.hasNext())
+        result.append(it.next());
+    return result;
+}
+
+static QString freeRTOSEnvVarForPlatform(const QString &platform)
+{
+    if (platform == "STM32F769I-DISCOVERY" || platform == "STM32F7508-DISCOVERY")
+        return "STM32F7_FREERTOS_DIR";
+    else if (platform == "MIMXRT1050-EVK")
+        return "IMXRT1050_FREERTOS_DIR";
+    else if (platform == "MIMXRT1064-EVK")
+        return "IMXRT1064_FREERTOS_DIR";
+
+    return {};
+}
+
+static McuTargetDescription parseDescriptionJson(const QByteArray &data)
+{
+    const QJsonDocument document = QJsonDocument::fromJson(data);
+    const QJsonObject target = document.object();
+    const QJsonObject toolchain = target.value("toolchain").toObject();
+    const QJsonObject boardSdk = target.value("boardSdk").toObject();
+
+    const QString platform = target.value("platform").toString();
+
+    const QVariantList colorDepths = target.value("colorDepths").toArray().toVariantList();
+    const auto colorDepthsVector = Utils::transform<QVector<int> >(
+                colorDepths, [&](const QVariant &colorDepth) { return colorDepth.toInt(); });
+
+    return {
+        target.value("qulVersion").toString(),
+        platform,
+        target.value("platformVendor").toString(),
+        colorDepthsVector,
+        toolchain.value("id").toString(),
+        boardSdk.value("boardSdkEnvVar").toString(),
+        freeRTOSEnvVarForPlatform(platform) // Workaround for UL-2514: Missing FreeRTOS information
+    };
+}
+
+void targetsAndPackages(const Utils::FilePath &dir, QVector<McuPackage *> *packages,
+                        QVector<McuTarget *> *mcuTargets)
+{
+    QList<McuTargetDescription> descriptions;
+
+    for (const QFileInfo &fileInfo : targetDescriptionFiles(dir)) {
+        QFile file(fileInfo.absoluteFilePath());
+        if (!file.open(QFile::ReadOnly))
+            continue;
+        const McuTargetDescription desc = parseDescriptionJson(file.readAll());
+        if (!McuSupportOptions::supportedQulVersion()
+                .isPrefixOf(QVersionNumber::fromString(desc.qulVersion)))
+            continue;
+        descriptions.append(desc);
+    }
+
+    if (!descriptions.isEmpty()) {
+        // Workaround for missing JSON file for Desktop target:
+        descriptions.prepend({McuSupportOptions::supportedQulVersion().toString(),
+                              "Qt", "Qt", {32}, "desktop", {}, {}});
+
+        mcuTargets->append(targetsFromDescriptions(descriptions, packages));
+    }
 }
 
 } // namespace Sdk

src/plugins/mcusupport/mcusupportsdk.h

@@ -27,6 +27,10 @@
 
 #include <QVector>
 
+namespace Utils {
+class FilePath;
+}
+
 namespace McuSupport {
 namespace Internal {
 class McuPackage;
@@ -36,9 +40,8 @@ namespace Sdk {
 
 McuPackage *createQtForMCUsPackage();
 
-// Legacy: List of targets supported by Qt for MCUs 1.0
+void targetsAndPackages(const Utils::FilePath &qulDir,
-void hardcodedTargetsAndPackages(const Utils::FilePath &qulDir,
+                        QVector<McuPackage*> *packages, QVector<McuTarget*> *mcuTargets);
-                                 QVector<McuPackage*> *packages, QVector<McuTarget*> *mcuTargets);
 
 } // namespace Sdk
 } // namespace Internal