Qnx: Refactor BlackBerryConfiguration

Improve the NDK setting page to enable managing multiple NDKs.

* Refactor BlackBerryConfiguration to support multiple configurations
* Add auto detected kits for installed NDKs
* Add/Remove manual NDKs

Change-Id: Icbc850551da3f729ccaa3473da720ade3051adaf
Reviewed-by: Tobias Hunger <tobias.hunger@digia.com>
Reviewed-by: Wolfgang Bremer <wbremer@blackberry.com>

src/plugins/qnx/blackberrycertificate.cpp

@@ -31,6 +31,7 @@
 
 #include "blackberrycertificate.h"
 #include "blackberryconfiguration.h"
+#include "blackberryconfigurationmanager.h"
 
 #include <utils/hostosinfo.h>
 
@@ -178,12 +179,16 @@ void BlackBerryCertificate::processError()
 
 QString BlackBerryCertificate::command() const
 {
-    QString command = BlackBerryConfiguration::instance()
-        .qnxEnv().value(QLatin1String("QNX_HOST"))
-        + QLatin1String("/usr/bin/blackberry-keytool");
+    QString command;
+    // TOOD: Give user choice to select NDK from where to get commands
+    QMultiMap<QString, QString> qnxEnv = BlackBerryConfigurationManager::instance().defaultQnxEnv();
+    if (!qnxEnv.isEmpty()) {
+        command = qnxEnv.value(QLatin1String("QNX_HOST"))
+                + QLatin1String("/usr/bin/blackberry-keytool");
 
-    if (Utils::HostOsInfo::isWindowsHost())
-        command += QLatin1String(".bat");
+        if (Utils::HostOsInfo::isWindowsHost())
+            command += QLatin1String(".bat");
+    }
 
     return command;
 }

src/plugins/qnx/blackberrycertificatemodel.cpp

@@ -31,7 +31,7 @@
 
 #include "blackberrycertificatemodel.h"
 #include "blackberrycertificate.h"
-#include "blackberryconfiguration.h"
+#include "blackberryconfigurationmanager.h"
 
 #include <coreplugin/icore.h>
 
@@ -196,9 +196,9 @@ bool BlackBerryCertificateModel::insertCertificate(BlackBerryCertificate *certif
 
 void BlackBerryCertificateModel::load()
 {
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
-    m_certificates = configuration.certificates();
-    m_activeCertificate = configuration.activeCertificate();
+    BlackBerryConfigurationManager &configManager = BlackBerryConfigurationManager::instance();
+    m_certificates = configManager.certificates();
+    m_activeCertificate = configManager.activeCertificate();
 }
 
 } // namespace Internal

src/plugins/qnx/blackberryconfiguration.cpp

@@ -31,28 +31,22 @@
 
 #include "blackberryconfiguration.h"
 #include "blackberryqtversion.h"
-#include "blackberrycertificate.h"
+
 #include "qnxutils.h"
 
-#include <coreplugin/icore.h>
+#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/kitmanager.h>
+#include <projectexplorer/kitinformation.h>
+#include <projectexplorer/toolchainmanager.h>
 
 #include <qtsupport/baseqtversion.h>
 #include <qtsupport/qtversionmanager.h>
 #include <qtsupport/qtkitinformation.h>
 
-#include <projectexplorer/projectexplorerconstants.h>
-#include <projectexplorer/kitmanager.h>
-#include <projectexplorer/kitinformation.h>
-#include <projectexplorer/gcctoolchain.h>
-#include <projectexplorer/toolchainmanager.h>
-
 #include <qt4projectmanager/qmakekitinformation.h>
 
 #include <debugger/debuggerkitinformation.h>
 
-#include <utils/persistentsettings.h>
-#include <utils/hostosinfo.h>
-
 #include <QFileInfo>
 #include <QDir>
 #include <QMessageBox>
@@ -60,31 +54,117 @@
 namespace Qnx {
 namespace Internal {
 
-namespace {
-const QLatin1String SettingsGroup("BlackBerryConfiguration");
-const QLatin1String NDKLocationKey("NDKLocation");
-const QLatin1String CertificateGroup("Certificates");
+BlackBerryConfiguration::BlackBerryConfiguration(const QString &ndkPath, bool isAutoDetected, const QString &displayName)
+{
+    m_ndkPath = ndkPath;
+    m_isAutoDetected = isAutoDetected;
+    m_displayName = displayName.isEmpty() ? m_ndkPath.split(QDir::separator()).last() : displayName;
+    m_qnxEnv = QnxUtils::parseEnvironmentFile(QnxUtils::envFilePath(m_ndkPath));
+
+    QString ndkTarget = m_qnxEnv.value(QLatin1String("QNX_TARGET"));
+    QString sep = QString::fromLatin1("%1qnx6").arg(QDir::separator());
+    m_targetName = ndkTarget.split(sep).first().split(QDir::separator()).last();
+
+    if (QDir(ndkTarget).exists())
+        m_sysRoot = Utils::FileName::fromString(ndkTarget);
+
+    QString qnxHost = m_qnxEnv.value(QLatin1String("QNX_HOST"));
+    Utils::FileName qmake4Path = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/qmake")));
+    Utils::FileName qmake5Path = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/qt5/qmake")));
+    Utils::FileName gccPath = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/qcc")));
+    Utils::FileName deviceGdbPath = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/ntoarm-gdb")));
+    Utils::FileName simulatorGdbPath = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/ntox86-gdb")));
+
+    if (qmake4Path.toFileInfo().exists())
+        m_qmake4BinaryFile = qmake4Path;
+
+    if (qmake5Path.toFileInfo().exists())
+        m_qmake5BinaryFile = qmake5Path;
+
+    if (gccPath.toFileInfo().exists())
+        m_gccCompiler = gccPath;
+
+    if (deviceGdbPath.toFileInfo().exists())
+        m_deviceDebuger = deviceGdbPath;
+
+    if (simulatorGdbPath.toFileInfo().exists())
+        m_simulatorDebuger = simulatorGdbPath;
+
 }
 
-BlackBerryConfiguration::BlackBerryConfiguration(QObject *parent)
-    :QObject(parent)
+QString BlackBerryConfiguration::ndkPath() const
 {
-    loadSettings();
-    connect(Core::ICore::instance(), SIGNAL(saveSettingsRequested()), this, SLOT(saveSettings()));
+    return m_ndkPath;
 }
 
-bool BlackBerryConfiguration::setNdkPath(const QString &ndkPath)
+QString BlackBerryConfiguration::displayName() const
 {
-    if (ndkPath.isEmpty())
-        return false;
-
-    m_config.ndkPath = ndkPath;
-
-    return refresh();
+    return m_displayName;
 }
 
-void BlackBerryConfiguration::setupNdkConfigPerQtVersion(const Utils::FileName &qmakePath, ProjectExplorer::GccToolChain *tc)
+QString BlackBerryConfiguration::targetName() const
 {
+    return m_targetName;
+}
+
+bool BlackBerryConfiguration::isAutoDetected() const
+{
+    return m_isAutoDetected;
+}
+
+bool BlackBerryConfiguration::isActive() const
+{
+    QtSupport::BaseQtVersion *qt4Version = QtSupport::QtVersionManager::instance()->qtVersionForQMakeBinary(m_qmake4BinaryFile);
+    QtSupport::BaseQtVersion *qt5Version = QtSupport::QtVersionManager::instance()->qtVersionForQMakeBinary(m_qmake5BinaryFile);
+    return (qt4Version || qt5Version);
+}
+
+bool BlackBerryConfiguration::isValid() const
+{
+    return !((m_qmake4BinaryFile.isEmpty() && m_qmake5BinaryFile.isEmpty()) || m_gccCompiler.isEmpty()
+            || m_deviceDebuger.isEmpty() || m_simulatorDebuger.isEmpty());
+}
+
+Utils::FileName BlackBerryConfiguration::qmake4BinaryFile() const
+{
+    return m_qmake4BinaryFile;
+}
+
+Utils::FileName BlackBerryConfiguration::qmake5BinaryFile() const
+{
+    return m_qmake5BinaryFile;
+}
+
+Utils::FileName BlackBerryConfiguration::gccCompiler() const
+{
+    return m_gccCompiler;
+}
+
+Utils::FileName BlackBerryConfiguration::deviceDebuger() const
+{
+    return m_deviceDebuger;
+}
+
+Utils::FileName BlackBerryConfiguration::simulatorDebuger() const
+{
+    return m_simulatorDebuger;
+}
+
+Utils::FileName BlackBerryConfiguration::sysRoot() const
+{
+    return m_sysRoot;
+}
+
+QMultiMap<QString, QString> BlackBerryConfiguration::qnxEnv() const
+{
+    return m_qnxEnv;
+}
+
+void BlackBerryConfiguration::setupConfigurationPerQtVersion(const Utils::FileName &qmakePath, ProjectExplorer::GccToolChain *tc)
+{
+    if (qmakePath.isEmpty() || !tc)
+        return;
+
     QtSupport::BaseQtVersion *qtVersion = createQtVersion(qmakePath);
     ProjectExplorer::Kit *deviceKit = createKit(ArmLeV7, qtVersion, tc);
     ProjectExplorer::Kit *simulatorKit = createKit(X86, qtVersion, tc);
@@ -96,160 +176,160 @@ void BlackBerryConfiguration::setupNdkConfigPerQtVersion(const Utils::FileName &
         ProjectExplorer::ToolChainManager::instance()->registerToolChain(tc);
         ProjectExplorer::KitManager::instance()->registerKit(deviceKit);
         ProjectExplorer::KitManager::instance()->registerKit(simulatorKit);
-
-        emit updated();
     }
 }
 
-bool BlackBerryConfiguration::refresh()
+QtSupport::BaseQtVersion *BlackBerryConfiguration::createQtVersion(const Utils::FileName &qmakePath)
 {
-    m_config.qnxEnv = QnxUtils::parseEnvironmentFile(QnxUtils::envFilePath(m_config.ndkPath));
+    if (qmakePath.isEmpty())
+        return 0;
 
-    QString ndkTarget = m_config.qnxEnv.value(QLatin1String("QNX_TARGET"));
-    QString sep = QString::fromLatin1("%1qnx6").arg(QDir::separator());
-    m_config.targetName = ndkTarget.split(sep).first().split(QDir::separator()).last();
+    QString cpuDir = m_qnxEnv.value(QLatin1String("CPUVARDIR"));
+    QtSupport::BaseQtVersion *version = QtSupport::QtVersionManager::instance()->qtVersionForQMakeBinary(qmakePath);
+    if (version) {
+        if (!m_isAutoDetected)
+            QMessageBox::warning(0, QObject::tr("Qt Version Already Known"),
+                             QObject::tr("This Qt version was already registered."), QMessageBox::Ok);
+        return version;
+    }
 
-    if (QDir(ndkTarget).exists())
-        m_config.sysRoot = Utils::FileName::fromString(ndkTarget);
+    version = new BlackBerryQtVersion(QnxUtils::cpudirToArch(cpuDir), qmakePath, m_isAutoDetected, QString(), m_ndkPath);
+    if (!version) {
+        if (!m_isAutoDetected)
+            QMessageBox::warning(0, QObject::tr("Invalid Qt Version"),
+                             QObject::tr("Unable to add BlackBerry Qt version."), QMessageBox::Ok);
+        return 0;
+    }
 
-    QString qnxHost = m_config.qnxEnv.value(QLatin1String("QNX_HOST"));
-    Utils::FileName qmake4Path = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/qmake")));
-    Utils::FileName qmake5Path = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/qt5/qmake")));
-    Utils::FileName gccPath = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/qcc")));
-    Utils::FileName deviceGdbPath = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/ntoarm-gdb")));
-    Utils::FileName simulatorGdbPath = QnxUtils::executableWithExtension(Utils::FileName::fromString(qnxHost + QLatin1String("/usr/bin/ntox86-gdb")));
+    version->setDisplayName(QString::fromLatin1("Qt %1 BlackBerry 10 (%2)").arg(version->qtVersionString(), m_targetName));
+    return version;
+}
 
-    if ((!qmake4Path.toFileInfo().exists() && !qmake5Path.toFileInfo().exists()) || !gccPath.toFileInfo().exists()
-            || !deviceGdbPath.toFileInfo().exists() || !simulatorGdbPath.toFileInfo().exists() ) {
-        QString errorMessage = tr("The following errors occurred while setting up BB10 Configuration:");
-        if (!qmake4Path.toFileInfo().exists() && !qmake5Path.toFileInfo().exists())
-            errorMessage += QLatin1Char('\n') + tr("- No Qt version found.");
+ProjectExplorer::GccToolChain *BlackBerryConfiguration::createGccToolChain()
+{
+    if ((m_qmake4BinaryFile.isEmpty() && m_qmake5BinaryFile.isEmpty()) || m_gccCompiler.isEmpty())
+        return 0;
 
-        if (!gccPath.toFileInfo().exists())
-            errorMessage += QLatin1Char('\n') + tr("- No GCC compiler found.");
+    foreach (ProjectExplorer::ToolChain* tc, ProjectExplorer::ToolChainManager::instance()->toolChains()) {
+        if (tc->compilerCommand() == m_gccCompiler) {
+            if (!m_isAutoDetected)
+                QMessageBox::warning(0, QObject::tr("Compiler Already Known"),
+                                 QObject::tr("This compiler was already registered."), QMessageBox::Ok);
+            return dynamic_cast<ProjectExplorer::GccToolChain*>(tc);
+        }
+    }
 
-        if (!deviceGdbPath.toFileInfo().exists())
-            errorMessage += QLatin1Char('\n') + tr("- No GDB debugger found for BB10 Device.");
+    ProjectExplorer::GccToolChain* tc = new ProjectExplorer::GccToolChain(QLatin1String(ProjectExplorer::Constants::GCC_TOOLCHAIN_ID), m_isAutoDetected);
+    tc->setDisplayName(QString::fromLatin1("GCC BlackBerry 10 (%1)").arg(m_targetName));
+    tc->setCompilerCommand(m_gccCompiler);
 
-        if (!simulatorGdbPath.toFileInfo().exists())
-            errorMessage += QLatin1Char('\n') + tr("- No GDB debugger found for BB10 Simulator.");
+    return tc;
+}
 
-        QMessageBox::warning(0, tr("Cannot Set up BB10 Configuration"),
+ProjectExplorer::Kit *BlackBerryConfiguration::createKit(QnxArchitecture arch, QtSupport::BaseQtVersion *qtVersion, ProjectExplorer::GccToolChain *tc)
+{
+    if (!qtVersion || !tc || m_targetName.isEmpty())
+        return 0;
+
+    // Check if an identical kit already exists
+    foreach (ProjectExplorer::Kit *kit, ProjectExplorer::KitManager::instance()->kits())
+    {
+        if (QtSupport::QtKitInformation::qtVersion(kit) == qtVersion && ProjectExplorer::ToolChainKitInformation::toolChain(kit) == tc
+                && ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(kit) == Constants::QNX_BB_OS_TYPE
+                && ProjectExplorer::SysRootKitInformation::sysRoot(kit) == m_sysRoot) {
+            if ((arch == X86 && Qt4ProjectManager::QmakeKitInformation::mkspec(kit).toString() == QString::fromLatin1("blackberry-x86-qcc")
+                 && Debugger::DebuggerKitInformation::debuggerCommand(kit) == m_simulatorDebuger)
+                    || (arch == ArmLeV7 && Debugger::DebuggerKitInformation::debuggerCommand(kit) == m_deviceDebuger)) {
+                if (!m_isAutoDetected)
+                    QMessageBox::warning(0, QObject::tr("Kit Already Known"),
+                                     QObject::tr("This kit was already registered."), QMessageBox::Ok);
+                setSticky(kit);
+                return kit;
+            }
+        }
+    }
+
+    ProjectExplorer::Kit *kit = new ProjectExplorer::Kit;
+    QtSupport::QtKitInformation::setQtVersion(kit, qtVersion);
+    ProjectExplorer::ToolChainKitInformation::setToolChain(kit, tc);
+    if (arch == X86) {
+        Debugger::DebuggerKitInformation::setDebuggerCommand(kit, m_simulatorDebuger);
+        Qt4ProjectManager::QmakeKitInformation::setMkspec(kit, Utils::FileName::fromString(QString::fromLatin1("blackberry-x86-qcc")));
+        // TODO: Check if the name already exists(?)
+        kit->setDisplayName(QObject::tr("BlackBerry 10 (%1 - %2) - Simulator").arg(qtVersion->qtVersionString(), m_targetName));
+    } else {
+        Debugger::DebuggerKitInformation::setDebuggerCommand(kit, m_deviceDebuger);
+        kit->setDisplayName(QObject::tr("BlackBerry 10 (%1 - %2)").arg(qtVersion->qtVersionString(), m_targetName));
+    }
+
+
+    kit->setAutoDetected(m_isAutoDetected);
+    kit->setIconPath(QLatin1String(Constants::QNX_BB_CATEGORY_ICON));
+    setSticky(kit);
+    ProjectExplorer::DeviceTypeKitInformation::setDeviceTypeId(kit, Constants::QNX_BB_OS_TYPE);
+    ProjectExplorer::SysRootKitInformation::setSysRoot(kit, m_sysRoot);
+
+    return kit;
+}
+
+void BlackBerryConfiguration::setSticky(ProjectExplorer::Kit *kit)
+{
+    kit->makeSticky(Core::Id("QtSupport.QtInformation"));
+    kit->makeSticky(Core::Id("PE.Profile.ToolChain"));
+    kit->makeSticky(Core::Id("PE.Profile.SysRoot"));
+    kit->makeSticky(Core::Id("PE.Profile.DeviceType"));
+    kit->makeSticky(Core::Id("Debugger.Information"));
+    kit->makeSticky(Core::Id("QtPM4.mkSpecInformation"));
+}
+
+bool BlackBerryConfiguration::activate()
+{
+    if (!isValid()) {
+        if (m_isAutoDetected)
+            return false;
+
+        QString errorMessage = QObject::tr("The following errors occurred while activating NDK: %1").arg(m_ndkPath);
+        if (m_qmake4BinaryFile.isEmpty() && m_qmake4BinaryFile.isEmpty())
+            errorMessage += QLatin1Char('\n') + QObject::tr("- No Qt version found.");
+
+        if (m_gccCompiler.isEmpty())
+            errorMessage += QLatin1Char('\n') + QObject::tr("- No GCC compiler found.");
+
+        if (m_deviceDebuger.isEmpty())
+            errorMessage += QLatin1Char('\n') + QObject::tr("- No GDB debugger found for BB10 Device.");
+
+        if (!m_simulatorDebuger.isEmpty())
+            errorMessage += QLatin1Char('\n') + QObject::tr("- No GDB debugger found for BB10 Simulator.");
+
+        QMessageBox::warning(0, QObject::tr("Cannot Set up BB10 Configuration"),
                              errorMessage, QMessageBox::Ok);
         return false;
     }
 
-    if (qmake4Path.toFileInfo().exists())
-        m_config.qmake4BinaryFile = qmake4Path;
+    if (isActive() && !m_isAutoDetected)
+        return true;
 
-    if (qmake5Path.toFileInfo().exists())
-        m_config.qmake5BinaryFile = qmake5Path;
+    ProjectExplorer::GccToolChain *tc = createGccToolChain();
+    if (!m_qmake4BinaryFile.isEmpty())
+        setupConfigurationPerQtVersion(m_qmake4BinaryFile, tc);
 
-    m_config.gccCompiler = gccPath;
-    m_config.deviceDebuger = deviceGdbPath;
-    m_config.simulatorDebuger = simulatorGdbPath;
+    if (!m_qmake4BinaryFile.isEmpty())
+        setupConfigurationPerQtVersion(m_qmake5BinaryFile, tc);
 
     return true;
 }
 
-void BlackBerryConfiguration::loadCertificates()
+void BlackBerryConfiguration::deactivate()
 {
-    QSettings *settings = Core::ICore::settings();
-
-    settings->beginGroup(SettingsGroup);
-    settings->beginGroup(CertificateGroup);
-
-    foreach (const QString &certificateId, settings->childGroups()) {
-        settings->beginGroup(certificateId);
-
-        BlackBerryCertificate *cert =
-            new BlackBerryCertificate(settings->value(QLatin1String(Qnx::Constants::QNX_KEY_PATH)).toString(),
-                    settings->value(QLatin1String(Qnx::Constants::QNX_KEY_AUTHOR)).toString());
-        cert->setParent(this);
-
-        if (settings->value(QLatin1String(Qnx::Constants::QNX_KEY_ACTIVE)).toBool())
-            m_config.activeCertificate = cert;
-
-        m_config.certificates << cert;
-
-        settings->endGroup();
-    }
-
-    settings->endGroup();
-    settings->endGroup();
-}
-
-void BlackBerryConfiguration::loadNdkSettings()
-{
-    QSettings *settings = Core::ICore::settings();
-
-    settings->beginGroup(SettingsGroup);
-    setNdkPath(settings->value(NDKLocationKey).toString());
-    settings->endGroup();
-}
-
-void BlackBerryConfiguration::saveCertificates()
-{
-    QSettings *settings = Core::ICore::settings();
-
-    settings->beginGroup(SettingsGroup);
-    settings->beginGroup(CertificateGroup);
-
-    settings->remove(QString());
-
-    foreach (const BlackBerryCertificate *cert, m_config.certificates) {
-        settings->beginGroup(cert->id());
-        settings->setValue(QLatin1String(Qnx::Constants::QNX_KEY_PATH), cert->fileName());
-        settings->setValue(QLatin1String(Qnx::Constants::QNX_KEY_AUTHOR), cert->author());
-
-        if (cert == m_config.activeCertificate)
-            settings->setValue(QLatin1String(Qnx::Constants::QNX_KEY_ACTIVE), true);
-
-        settings->endGroup();
-    }
-
-    settings->endGroup();
-    settings->endGroup();
-}
-
-void BlackBerryConfiguration::saveNdkSettings()
-{
-    if (m_config.ndkPath.isEmpty())
-        return;
-
-    QSettings *settings = Core::ICore::settings();
-    settings->beginGroup(SettingsGroup);
-    settings->setValue(NDKLocationKey, m_config.ndkPath);
-    settings->endGroup();
-}
-
-void BlackBerryConfiguration::setupNdkConfiguration(const QString &ndkPath)
-{
-    if (ndkPath.isEmpty())
-        return;
-
-    if (setNdkPath(ndkPath)) {
-        ProjectExplorer::GccToolChain *tc = createGccToolChain();
-
-        if (!m_config.qmake4BinaryFile.isEmpty())
-            setupNdkConfigPerQtVersion(m_config.qmake4BinaryFile, tc);
-
-        if (!m_config.qmake5BinaryFile.isEmpty())
-            setupNdkConfigPerQtVersion(m_config.qmake5BinaryFile, tc);
-    }
-}
-
-void BlackBerryConfiguration::cleanNdkConfiguration()
-{
-    QtSupport::BaseQtVersion *qt4Version = QtSupport::QtVersionManager::instance()->qtVersionForQMakeBinary(m_config.qmake4BinaryFile);
-    QtSupport::BaseQtVersion *qt5Version = QtSupport::QtVersionManager::instance()->qtVersionForQMakeBinary(m_config.qmake5BinaryFile);
+    QtSupport::BaseQtVersion *qt4Version = QtSupport::QtVersionManager::instance()->qtVersionForQMakeBinary(m_qmake4BinaryFile);
+    QtSupport::BaseQtVersion *qt5Version = QtSupport::QtVersionManager::instance()->qtVersionForQMakeBinary(m_qmake5BinaryFile);
     if (qt4Version || qt5Version) {
         foreach (ProjectExplorer::Kit *kit, ProjectExplorer::KitManager::instance()->kits()) {
-            if (qt4Version && qt4Version == QtSupport::QtKitInformation::qtVersion(kit)) {
+            if (qt4Version && qt4Version == QtSupport::QtKitInformation::qtVersion(kit))
                 ProjectExplorer::KitManager::instance()->deregisterKit(kit);
-            } else if (qt5Version && qt5Version == QtSupport::QtKitInformation::qtVersion(kit)) {
+
+            else if (qt5Version && qt5Version == QtSupport::QtKitInformation::qtVersion(kit))
                 ProjectExplorer::KitManager::instance()->deregisterKit(kit);
-            }
         }
 
         if (qt4Version)
@@ -261,250 +341,10 @@ void BlackBerryConfiguration::cleanNdkConfiguration()
     }
 
     foreach (ProjectExplorer::ToolChain* tc, ProjectExplorer::ToolChainManager::instance()->toolChains()) {
-        if (tc->compilerCommand() == m_config.gccCompiler)
+        if (tc->compilerCommand() == m_gccCompiler)
             ProjectExplorer::ToolChainManager::instance()->deregisterToolChain(tc);
     }
-
-    BlackBerryConfig conf;
-    conf.activeCertificate = m_config.activeCertificate;
-    conf.certificates = m_config.certificates;
-    m_config = conf;
-    emit updated();
-
-    clearNdkSettings();
 }
 
-void BlackBerryConfiguration::syncCertificates(QList<BlackBerryCertificate*> certificates,
-        BlackBerryCertificate *activeCertificate)
-{
-    m_config.activeCertificate = activeCertificate;
-
-    foreach (BlackBerryCertificate *cert, m_config.certificates) {
-        if (!certificates.contains(cert))
-            removeCertificate(cert);
-    }
-
-    foreach (BlackBerryCertificate *cert, certificates)
-        addCertificate(cert);
-}
-
-void BlackBerryConfiguration::addCertificate(BlackBerryCertificate *certificate)
-{
-    if (m_config.certificates.contains(certificate))
-        return;
-
-    if (m_config.certificates.isEmpty())
-        m_config.activeCertificate = certificate;
-
-    certificate->setParent(this);
-    m_config.certificates << certificate;
-}
-
-void BlackBerryConfiguration::removeCertificate(BlackBerryCertificate *certificate)
-{
-    if (m_config.activeCertificate == certificate)
-        m_config.activeCertificate = 0;
-
-    m_config.certificates.removeAll(certificate);
-
-    delete certificate;
-}
-
-QList<BlackBerryCertificate*> BlackBerryConfiguration::certificates() const
-{
-    return m_config.certificates;
-}
-
-BlackBerryCertificate * BlackBerryConfiguration::activeCertificate()
-{
-    return m_config.activeCertificate;
-}
-
-QtSupport::BaseQtVersion *BlackBerryConfiguration::createQtVersion(const Utils::FileName &qmakePath)
-{
-    if (qmakePath.isEmpty())
-        return 0;
-
-    QString cpuDir = m_config.qnxEnv.value(QLatin1String("CPUVARDIR"));
-    QtSupport::BaseQtVersion *version = QtSupport::QtVersionManager::instance()->qtVersionForQMakeBinary(qmakePath);
-    if (version) {
-        QMessageBox::warning(0, tr("Qt Version Already Known"),
-                             tr("This Qt version was already registered."), QMessageBox::Ok);
-        return version;
-    }
-
-    version = new BlackBerryQtVersion(QnxUtils::cpudirToArch(cpuDir), qmakePath, false, QString(), m_config.ndkPath);
-    if (!version) {
-        QMessageBox::warning(0, tr("Invalid Qt Version"),
-                             tr("Unable to add BlackBerry Qt version."), QMessageBox::Ok);
-        return 0;
-    }
-
-    version->setDisplayName(QString::fromLatin1("Qt %1 BlackBerry 10 (%2)").arg(version->qtVersionString(), m_config.targetName));
-
-    return version;
-}
-
-ProjectExplorer::GccToolChain *BlackBerryConfiguration::createGccToolChain()
-{
-    if ((m_config.qmake4BinaryFile.isEmpty() && m_config.qmake5BinaryFile.isEmpty()) || m_config.gccCompiler.isEmpty())
-        return 0;
-
-    foreach (ProjectExplorer::ToolChain* tc, ProjectExplorer::ToolChainManager::instance()->toolChains()) {
-        if (tc->compilerCommand() == m_config.gccCompiler) {
-            QMessageBox::warning(0, tr("Compiler Already Known"),
-                                 tr("This compiler was already registered."), QMessageBox::Ok);
-            return dynamic_cast<ProjectExplorer::GccToolChain*>(tc);
-        }
-    }
-
-    ProjectExplorer::GccToolChain* tc = new ProjectExplorer::GccToolChain(QLatin1String(ProjectExplorer::Constants::GCC_TOOLCHAIN_ID), false);
-    tc->setDisplayName(QString::fromLatin1("GCC BlackBerry 10 (%1)").arg(m_config.targetName));
-    tc->setCompilerCommand(m_config.gccCompiler);
-
-    return tc;
-}
-
-ProjectExplorer::Kit *BlackBerryConfiguration::createKit(QnxArchitecture arch, QtSupport::BaseQtVersion *qtVersion, ProjectExplorer::GccToolChain *tc)
-{
-    if (!qtVersion || !tc || m_config.targetName.isEmpty())
-        return 0;
-
-    // Check if an identical kit already exists
-    foreach (ProjectExplorer::Kit *kit, ProjectExplorer::KitManager::instance()->kits())
-    {
-        if (QtSupport::QtKitInformation::qtVersion(kit) == qtVersion && ProjectExplorer::ToolChainKitInformation::toolChain(kit) == tc
-                && ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(kit) == Constants::QNX_BB_OS_TYPE
-                && ProjectExplorer::SysRootKitInformation::sysRoot(kit) == m_config.sysRoot) {
-            if ((arch == X86 && Qt4ProjectManager::QmakeKitInformation::mkspec(kit).toString() == QString::fromLatin1("blackberry-x86-qcc")
-                 && Debugger::DebuggerKitInformation::debuggerCommand(kit) == m_config.simulatorDebuger)
-                    || (arch == ArmLeV7 && Debugger::DebuggerKitInformation::debuggerCommand(kit) == m_config.deviceDebuger)) {
-                QMessageBox::warning(0, tr("Kit Already Known"),
-                                     tr("This kit was already registered."), QMessageBox::Ok);
-                return kit;
-            }
-        }
-    }
-
-    ProjectExplorer::Kit *kit = new ProjectExplorer::Kit;
-    QtSupport::QtKitInformation::setQtVersion(kit, qtVersion);
-    ProjectExplorer::ToolChainKitInformation::setToolChain(kit, tc);
-    if (arch == X86) {
-        Debugger::DebuggerKitInformation::setDebuggerCommand(kit, m_config.simulatorDebuger);
-        Qt4ProjectManager::QmakeKitInformation::setMkspec(kit, Utils::FileName::fromString(QString::fromLatin1("blackberry-x86-qcc")));
-        // TODO: Check if the name already exists(?)
-        kit->setDisplayName(tr("BlackBerry 10 (%1 - %2) - Simulator").arg(qtVersion->qtVersionString(), m_config.targetName));
-    } else {
-        Debugger::DebuggerKitInformation::setDebuggerCommand(kit, m_config.deviceDebuger);
-        kit->setDisplayName(tr("BlackBerry 10 (%1 - %2)").arg(qtVersion->qtVersionString(), m_config.targetName));
-    }
-
-    kit->setIconPath(QLatin1String(Constants::QNX_BB_CATEGORY_ICON));
-    ProjectExplorer::DeviceTypeKitInformation::setDeviceTypeId(kit, Constants::QNX_BB_OS_TYPE);
-    ProjectExplorer::SysRootKitInformation::setSysRoot(kit, m_config.sysRoot);
-
-    return kit;
-}
-
-void BlackBerryConfiguration::loadSettings()
-{
-    loadNdkSettings();
-    loadCertificates();
-}
-
-void BlackBerryConfiguration::saveSettings()
-{
-    saveNdkSettings();
-    saveCertificates();
-}
-
-void BlackBerryConfiguration::clearNdkSettings()
-{
-    QSettings *settings = Core::ICore::settings();
-    settings->beginGroup(SettingsGroup);
-    settings->remove(NDKLocationKey);
-    settings->endGroup();
-}
-
-BlackBerryConfiguration &BlackBerryConfiguration::instance()
-{
-    if (m_instance == 0)
-        m_instance = new BlackBerryConfiguration();
-    return *m_instance;
-}
-
-QString BlackBerryConfiguration::ndkPath() const
-{
-    return m_config.ndkPath;
-}
-
-QString BlackBerryConfiguration::targetName() const
-{
-    return m_config.targetName;
-}
-
-BlackBerryConfig BlackBerryConfiguration::config() const
-{
-    return m_config;
-}
-
-Utils::FileName BlackBerryConfiguration::qmake4Path() const
-{
-    return m_config.qmake4BinaryFile;
-}
-
-Utils::FileName BlackBerryConfiguration::qmake5Path() const
-{
-    return m_config.qmake5BinaryFile;
-}
-
-Utils::FileName BlackBerryConfiguration::gccPath() const
-{
-    return m_config.gccCompiler;
-}
-
-Utils::FileName BlackBerryConfiguration::deviceGdbPath() const
-{
-    return m_config.deviceDebuger;
-}
-
-Utils::FileName BlackBerryConfiguration::simulatorGdbPath() const
-{
-    return m_config.simulatorDebuger;
-}
-
-Utils::FileName BlackBerryConfiguration::sysRoot() const
-{
-    return m_config.sysRoot;
-}
-
-QString BlackBerryConfiguration::barsignerCskPath() const
-{
-    return QnxUtils::dataDirPath() + QLatin1String("/barsigner.csk");
-}
-
-QString BlackBerryConfiguration::barsignerDbPath() const
-{
-    return QnxUtils::dataDirPath() + QLatin1String("/barsigner.db");
-}
-
-QString BlackBerryConfiguration::defaultKeystorePath() const
-{
-    return QnxUtils::dataDirPath() + QLatin1String("/author.p12");
-}
-
-QString BlackBerryConfiguration::defaultDebugTokenPath() const
-{
-    return QnxUtils::dataDirPath() + QLatin1String("/debugtoken.bar");
-}
-
-// TODO: QnxUtils::parseEnvFile() and qnxEnv() to return Util::Enviroment instead(?)
-QMultiMap<QString, QString> BlackBerryConfiguration::qnxEnv() const
-{
-    return m_config.qnxEnv;
-}
-
-BlackBerryConfiguration* BlackBerryConfiguration::m_instance = 0;
-
 } // namespace Internal
 } // namespace Qnx

src/plugins/qnx/blackberryconfiguration.h

@@ -42,83 +42,50 @@
 #include <projectexplorer/kit.h>
 #include <projectexplorer/gcctoolchain.h>
 
-#include <QSettings>
 #include <QObject>
 
 namespace Qnx {
 namespace Internal {
 
-class BlackBerryCertificate;
-
-class BlackBerryConfig
+class BlackBerryConfiguration
 {
-    QString ndkPath;
-    QString targetName;
-    Utils::FileName qmake4BinaryFile;
-    Utils::FileName qmake5BinaryFile;
-    Utils::FileName gccCompiler;
-    Utils::FileName deviceDebuger;
-    Utils::FileName simulatorDebuger;
-    Utils::FileName sysRoot;
-    QMultiMap<QString, QString> qnxEnv;
-    QList<BlackBerryCertificate*> certificates;
-    BlackBerryCertificate *activeCertificate;
-
-    friend class BlackBerryConfiguration;
-};
-
-class BlackBerryConfiguration: public QObject
-{
-    Q_OBJECT
 public:
-    static BlackBerryConfiguration &instance();
-    BlackBerryConfig config() const;
-    Utils::FileName qmake4Path() const;
-    Utils::FileName qmake5Path() const;
-    Utils::FileName gccPath() const;
-    Utils::FileName deviceGdbPath() const;
-    Utils::FileName simulatorGdbPath() const;
+    BlackBerryConfiguration(const QString& ndkPath, bool isAutoDetected, const QString &displayName = QString());
+    bool activate();
+    void deactivate();
+    QString ndkPath() const;
+    QString displayName() const;
+    QString targetName() const;
+    bool isAutoDetected() const;
+    bool isActive() const;
+    bool isValid() const;
+    Utils::FileName qmake4BinaryFile() const;
+    Utils::FileName qmake5BinaryFile() const;
+    Utils::FileName gccCompiler() const;
+    Utils::FileName deviceDebuger() const;
+    Utils::FileName simulatorDebuger() const;
     Utils::FileName sysRoot() const;
     QMultiMap<QString, QString> qnxEnv() const;
-    void setupNdkConfiguration(const QString &ndkPath);
-    QString ndkPath() const;
-    QString targetName() const;
-    QString barsignerCskPath() const;
-    QString barsignerDbPath() const;
-    QString defaultKeystorePath() const;
-    QString defaultDebugTokenPath() const;
-    void loadSettings();
-    void clearNdkSettings();
-    void cleanNdkConfiguration();
-    void syncCertificates(QList<BlackBerryCertificate*> certificates,
-            BlackBerryCertificate *activeCertificate);
-    void addCertificate(BlackBerryCertificate *certificate);
-    void removeCertificate(BlackBerryCertificate *certificate);
-
-    QList<BlackBerryCertificate*> certificates() const;
-    BlackBerryCertificate *activeCertificate();
-
-public slots:
-    void saveSettings();
 
 private:
-    BlackBerryConfiguration(QObject *parent = 0);
-    static BlackBerryConfiguration *m_instance;
-    BlackBerryConfig m_config;
+    QString m_ndkPath;
+    QString m_displayName;
+    QString m_targetName;
+    bool m_isAutoDetected;
+    Utils::FileName m_qmake4BinaryFile;
+    Utils::FileName m_qmake5BinaryFile;
+    Utils::FileName m_gccCompiler;
+    Utils::FileName m_deviceDebuger;
+    Utils::FileName m_simulatorDebuger;
+    Utils::FileName m_sysRoot;
+    QMultiMap<QString, QString> m_qnxEnv;
 
-    void loadCertificates();
-    void loadNdkSettings();
-    void saveCertificates();
-    void saveNdkSettings();
-    bool refresh();
-    bool setNdkPath(const QString &ndkPath);
-    void setupNdkConfigPerQtVersion(const Utils::FileName &qmakePath, ProjectExplorer::GccToolChain* tc);
+    void setupConfigurationPerQtVersion(const Utils::FileName &qmakePath, ProjectExplorer::GccToolChain* tc);
     QtSupport::BaseQtVersion* createQtVersion(const Utils::FileName &qmakePath);
     ProjectExplorer::GccToolChain* createGccToolChain();
     ProjectExplorer::Kit* createKit(QnxArchitecture arch, QtSupport::BaseQtVersion* qtVersion, ProjectExplorer::GccToolChain* tc);
+    void setSticky(ProjectExplorer::Kit* kit);
 
-signals:
-    void updated();
 };
 
 } // namespace Internal

src/plugins/qnx/blackberryconfigurationmanager.cpp

@@ -0,0 +1,384 @@
+/**************************************************************************
+**
+** Copyright (C) 2011 - 2013 Research In Motion
+**
+** Contact: Research In Motion (blackberry-qt@qnx.com)
+** Contact: KDAB (info@kdab.com)
+**
+** 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 Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+
+#include "blackberryconfigurationmanager.h"
+#include "blackberrycertificate.h"
+#include "blackberryconfiguration.h"
+
+#include "qnxutils.h"
+
+#include <coreplugin/icore.h>
+
+#include <utils/persistentsettings.h>
+#include <utils/hostosinfo.h>
+
+#include <projectexplorer/kit.h>
+#include <projectexplorer/kitmanager.h>
+#include <projectexplorer/kitinformation.h>
+#include <projectexplorer/toolchainmanager.h>
+
+#include <qtsupport/qtversionmanager.h>
+#include <qtsupport/qtkitinformation.h>
+
+#include <QMessageBox>
+
+namespace Qnx {
+namespace Internal {
+
+namespace {
+const QLatin1String SettingsGroup("BlackBerryConfiguration");
+const QLatin1String NDKLocationKey("NDKLocation");
+const QLatin1String CertificateGroup("Certificates");
+const QLatin1String ManualNDKsGroup("ManualNDKs");
+}
+
+BlackBerryConfigurationManager::BlackBerryConfigurationManager(QObject *parent)
+    :QObject(parent)
+{
+    connect(Core::ICore::instance(), SIGNAL(saveSettingsRequested()), this, SLOT(saveSettings()));
+}
+
+void BlackBerryConfigurationManager::loadCertificates()
+{
+    QSettings *settings = Core::ICore::settings();
+
+    settings->beginGroup(SettingsGroup);
+    settings->beginGroup(CertificateGroup);
+
+    foreach (const QString &certificateId, settings->childGroups()) {
+        settings->beginGroup(certificateId);
+
+        BlackBerryCertificate *cert =
+                new BlackBerryCertificate(settings->value(QLatin1String(Qnx::Constants::QNX_KEY_PATH)).toString(),
+                                          settings->value(QLatin1String(Qnx::Constants::QNX_KEY_AUTHOR)).toString());
+        cert->setParent(this);
+
+        if (settings->value(QLatin1String(Qnx::Constants::QNX_KEY_ACTIVE)).toBool())
+            m_activeCertificate = cert;
+
+        m_certificates << cert;
+
+        settings->endGroup();
+    }
+
+    settings->endGroup();
+    settings->endGroup();
+}
+
+void BlackBerryConfigurationManager::loadManualConfigurations()
+{
+    QSettings *settings = Core::ICore::settings();
+
+    settings->beginGroup(SettingsGroup);
+    settings->beginGroup(ManualNDKsGroup);
+
+    foreach (const QString &manualNdk, settings->childGroups()) {
+        settings->beginGroup(manualNdk);
+        BlackBerryConfiguration *config = new BlackBerryConfiguration(settings->value(NDKLocationKey).toString(),
+                                                                      false);
+        if (!addConfiguration(config))
+            delete config;
+
+        settings->endGroup();
+    }
+
+    settings->endGroup();
+    settings->endGroup();
+}
+
+void BlackBerryConfigurationManager::loadAutoDetectedConfigurations()
+{
+    foreach (const NdkInstallInformation &ndkInfo, QnxUtils::installedNdks()) {
+        BlackBerryConfiguration *config = new BlackBerryConfiguration(ndkInfo.path, true, ndkInfo.name);
+        if (!addConfiguration(config))
+            delete config;
+    }
+}
+
+void BlackBerryConfigurationManager::saveCertificates()
+{
+    QSettings *settings = Core::ICore::settings();
+    settings->beginGroup(SettingsGroup);
+    settings->beginGroup(CertificateGroup);
+
+    settings->remove(QString());
+
+    foreach (const BlackBerryCertificate *cert, m_certificates) {
+        settings->beginGroup(cert->id());
+        settings->setValue(QLatin1String(Qnx::Constants::QNX_KEY_PATH), cert->fileName());
+        settings->setValue(QLatin1String(Qnx::Constants::QNX_KEY_AUTHOR), cert->author());
+
+        if (cert == m_activeCertificate)
+            settings->setValue(QLatin1String(Qnx::Constants::QNX_KEY_ACTIVE), true);
+
+        settings->endGroup();
+    }
+
+    settings->endGroup();
+    settings->endGroup();
+}
+
+void BlackBerryConfigurationManager::saveManualConfigurations()
+{
+    if (manualConfigurations().isEmpty())
+        return;
+
+    QSettings *settings = Core::ICore::settings();
+    settings->beginGroup(SettingsGroup);
+    settings->beginGroup(ManualNDKsGroup);
+
+    foreach (BlackBerryConfiguration *config, manualConfigurations()) {
+        settings->beginGroup(config->displayName());
+        settings->setValue(NDKLocationKey, config->ndkPath());
+        settings->endGroup();
+    }
+
+    settings->endGroup();
+    settings->endGroup();
+}
+
+// Remove no longer available 'auo detected' kits
+void BlackBerryConfigurationManager::clearInvalidConfigurations()
+{
+    QList<NdkInstallInformation> autoNdks = QnxUtils::installedNdks();
+    foreach (ProjectExplorer::Kit *kit, ProjectExplorer::KitManager::instance()->kits()) {
+        if (!kit->isAutoDetected())
+            continue;
+
+        if (kit->displayName().contains(QLatin1String("BlackBerry"))) {
+            // Check if related target is still installed
+            bool isValid = false;
+            foreach (const NdkInstallInformation &ndkInfo, autoNdks) {
+                if (ndkInfo.target == ProjectExplorer::SysRootKitInformation::sysRoot(kit).toString()) {
+                    isValid = true;
+                    break;
+                }
+            }
+
+            if (!isValid) {
+                QtSupport::QtVersionManager::instance()->removeVersion(QtSupport::QtKitInformation::qtVersion(kit));
+                ProjectExplorer::ToolChainManager::instance()->deregisterToolChain(
+                            ProjectExplorer::ToolChainKitInformation::toolChain(kit));
+                ProjectExplorer::KitManager::instance()->deregisterKit(kit);
+            }
+        }
+    }
+}
+
+bool BlackBerryConfigurationManager::addConfiguration(BlackBerryConfiguration *config)
+{
+    foreach (BlackBerryConfiguration *c, m_configs) {
+        if (c->ndkPath() == config->ndkPath()
+                && c->targetName() == config->targetName()) {
+            if (!config->isAutoDetected())
+                QMessageBox::warning(0, tr("NDK Already known"),
+                                 tr("The NDK already has a configuration."), QMessageBox::Ok);
+            return false;
+        }
+    }
+
+    if (config->activate()) {
+        m_configs.append(config);
+        return true;
+    }
+
+    return false;
+}
+
+void BlackBerryConfigurationManager::removeConfiguration(BlackBerryConfiguration *config)
+{
+    if (!config)
+        return;
+
+    if (config->isActive())
+        config->deactivate();
+
+    clearConfigurationSettings(config);
+
+    m_configs.removeAt(m_configs.indexOf(config));
+    delete config;
+}
+
+QList<BlackBerryConfiguration *> BlackBerryConfigurationManager::configurations() const
+{
+    return m_configs;
+}
+
+QList<BlackBerryConfiguration *> BlackBerryConfigurationManager::manualConfigurations() const
+{
+    QList<BlackBerryConfiguration*> manuals;
+    foreach (BlackBerryConfiguration *config, m_configs) {
+        if (!config->isAutoDetected())
+            manuals << config;
+    }
+
+    return manuals;
+}
+
+BlackBerryConfiguration *BlackBerryConfigurationManager::configurationFromNdkPath(const QString &ndkPath) const
+{
+    foreach (BlackBerryConfiguration *config, m_configs) {
+        if (config->ndkPath() == ndkPath)
+            return config;
+    }
+
+    return 0;
+}
+
+void BlackBerryConfigurationManager::syncCertificates(QList<BlackBerryCertificate*> certificates,
+                                                      BlackBerryCertificate *activeCertificate)
+{
+    activeCertificate = activeCertificate;
+
+    foreach (BlackBerryCertificate *cert, certificates) {
+        if (!certificates.contains(cert))
+            removeCertificate(cert);
+    }
+
+    foreach (BlackBerryCertificate *cert, certificates)
+        addCertificate(cert);
+}
+
+void BlackBerryConfigurationManager::addCertificate(BlackBerryCertificate *certificate)
+{
+    if (m_certificates.contains(certificate))
+        return;
+
+    if (m_certificates.isEmpty())
+        m_activeCertificate = certificate;
+
+    certificate->setParent(this);
+    m_certificates << certificate;
+}
+
+void BlackBerryConfigurationManager::removeCertificate(BlackBerryCertificate *certificate)
+{
+    if (m_activeCertificate == certificate)
+        m_activeCertificate = 0;
+
+    m_certificates.removeAll(certificate);
+
+    delete certificate;
+}
+
+QList<BlackBerryCertificate*> BlackBerryConfigurationManager::certificates() const
+{
+    return m_certificates;
+}
+
+BlackBerryCertificate * BlackBerryConfigurationManager::activeCertificate()
+{
+    return m_activeCertificate;
+}
+
+// Returns a valid qnxEnv map from a valid configuration;
+// Needed by other classes to get blackberry process path (keys registration, debug token...)
+QMultiMap<QString, QString> BlackBerryConfigurationManager::defaultQnxEnv()
+{
+    foreach (BlackBerryConfiguration *config, m_configs) {
+        if (!config->qnxEnv().isEmpty())
+            return config->qnxEnv();
+    }
+
+    return QMultiMap<QString, QString>();
+}
+
+void BlackBerryConfigurationManager::loadSettings()
+{
+    clearInvalidConfigurations();
+    loadAutoDetectedConfigurations();
+    loadManualConfigurations();
+    loadCertificates();
+}
+
+void BlackBerryConfigurationManager::clearConfigurationSettings(BlackBerryConfiguration *config)
+{
+    if (!config)
+        return;
+
+    QSettings *settings = Core::ICore::settings();
+    settings->beginGroup(SettingsGroup);
+    settings->beginGroup(ManualNDKsGroup);
+
+    foreach (const QString &manualNdk, settings->childGroups()) {
+        if (manualNdk == config->displayName()) {
+            settings->remove(manualNdk);
+            break;
+        }
+    }
+
+    settings->endGroup();
+    settings->endGroup();
+}
+
+void BlackBerryConfigurationManager::saveSettings()
+{
+    saveManualConfigurations();
+    saveCertificates();
+}
+
+BlackBerryConfigurationManager &BlackBerryConfigurationManager::instance()
+{
+    if (m_instance == 0)
+        m_instance = new BlackBerryConfigurationManager();
+
+    return *m_instance;
+}
+
+BlackBerryConfigurationManager::~BlackBerryConfigurationManager()
+{
+    qDeleteAll(m_configs);
+}
+
+QString BlackBerryConfigurationManager::barsignerCskPath() const
+{
+    return QnxUtils::dataDirPath() + QLatin1String("/barsigner.csk");
+}
+
+QString BlackBerryConfigurationManager::barsignerDbPath() const
+{
+    return QnxUtils::dataDirPath() + QLatin1String("/barsigner.db");
+}
+
+QString BlackBerryConfigurationManager::defaultKeystorePath() const
+{
+    return QnxUtils::dataDirPath() + QLatin1String("/author.p12");
+}
+
+QString BlackBerryConfigurationManager::defaultDebugTokenPath() const
+{
+    return QnxUtils::dataDirPath() + QLatin1String("/debugtoken.bar");
+}
+
+BlackBerryConfigurationManager* BlackBerryConfigurationManager::m_instance = 0;
+
+} // namespace Internal
+} // namespace Qnx

src/plugins/qnx/blackberryconfigurationmanager.h

@@ -0,0 +1,97 @@
+/**************************************************************************
+**
+** Copyright (C) 2011 - 2013 Research In Motion
+**
+** Contact: Research In Motion (blackberry-qt@qnx.com)
+** Contact: KDAB (info@kdab.com)
+**
+** 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 Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+
+#ifndef BLACKBERRYCONFIGURATIONMANAGER_H
+#define BLACKBERRYCONFIGURATIONMANAGER_H
+
+#include <utils/environment.h>
+#include <utils/fileutils.h>
+
+#include <QSettings>
+#include <QObject>
+
+namespace Qnx {
+namespace Internal {
+
+class BlackBerryConfiguration;
+class BlackBerryCertificate;
+
+class BlackBerryConfigurationManager : public QObject
+{
+    Q_OBJECT
+public:
+    static BlackBerryConfigurationManager &instance();
+    ~BlackBerryConfigurationManager();
+    bool addConfiguration(BlackBerryConfiguration *config);
+    void removeConfiguration(BlackBerryConfiguration *config);
+    QList<BlackBerryConfiguration*> configurations() const;
+    QList<BlackBerryConfiguration*> manualConfigurations() const;
+    BlackBerryConfiguration *configurationFromNdkPath(const QString &ndkPath) const;
+
+    QString barsignerCskPath() const;
+    QString barsignerDbPath() const;
+    QString defaultKeystorePath() const;
+    QString defaultDebugTokenPath() const;
+    void clearConfigurationSettings(BlackBerryConfiguration *config);
+    void syncCertificates(QList<BlackBerryCertificate*> certificates,
+            BlackBerryCertificate *activeCertificate);
+    void addCertificate(BlackBerryCertificate *certificate);
+    void removeCertificate(BlackBerryCertificate *certificate);
+
+    QList<BlackBerryCertificate*> certificates() const;
+    BlackBerryCertificate *activeCertificate();
+
+    QMultiMap<QString, QString> defaultQnxEnv();
+
+public slots:
+    void loadSettings();
+    void saveSettings();
+
+private:
+    BlackBerryConfigurationManager(QObject *parent = 0);
+    static BlackBerryConfigurationManager *m_instance;
+    QList<BlackBerryConfiguration*> m_configs;
+
+    QList<BlackBerryCertificate*> m_certificates;
+    BlackBerryCertificate *m_activeCertificate;
+
+    void loadCertificates();
+    void loadManualConfigurations();
+    void loadAutoDetectedConfigurations();
+    void saveCertificates();
+    void saveManualConfigurations();
+    void clearInvalidConfigurations();
+};
+
+} // namespace Internal
+} // namespace Qnx
+
+#endif // BLACKBERRYCONFIGURATIONMANAGER_H

src/plugins/qnx/blackberrycsjregistrar.cpp

@@ -30,6 +30,7 @@
 ****************************************************************************/
 
 #include "blackberrycsjregistrar.h"
+#include "blackberryconfigurationmanager.h"
 #include "blackberryconfiguration.h"
 
 #include <utils/hostosinfo.h>
@@ -57,9 +58,15 @@ void BlackBerryCsjRegistrar::tryRegister(const QStringList &csjFiles,
     if (m_process->state() != QProcess::NotRunning)
         return;
 
-    QString command = BlackBerryConfiguration::instance()
-        .qnxEnv().value(QLatin1String("QNX_HOST"))
-        + (QLatin1String("/usr/bin/blackberry-signer"));
+    if (BlackBerryConfigurationManager::instance().configurations().isEmpty())
+        return;
+
+    QMultiMap<QString, QString> qnxEnv = BlackBerryConfigurationManager::instance().defaultQnxEnv();
+    if (qnxEnv.isEmpty())
+        return;
+
+    QString command = qnxEnv.value(QLatin1String("QNX_HOST"))
+                                + (QLatin1String("/usr/bin/blackberry-signer"));
 
     if (Utils::HostOsInfo::isWindowsHost())
         command += QLatin1String(".bat");

src/plugins/qnx/blackberrydebugtokenrequestdialog.cpp

@@ -32,7 +32,7 @@
 #include "blackberrydebugtokenrequestdialog.h"
 #include "blackberrydebugtokenrequester.h"
 #include "blackberrydeviceinformation.h"
-#include "blackberryconfiguration.h"
+#include "blackberryconfigurationmanager.h"
 #include "blackberrycertificate.h"
 #include "ui_blackberrydebugtokenrequestdialog.h"
 
@@ -283,9 +283,9 @@ void BlackBerryDebugTokenRequestDialog::setBusy(bool busy)
 
 void BlackBerryDebugTokenRequestDialog::populateComboBox()
 {
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+    BlackBerryConfigurationManager &configManager = BlackBerryConfigurationManager::instance();
 
-    QList<BlackBerryCertificate*> certificates = configuration.certificates();
+    QList<BlackBerryCertificate*> certificates = configManager.certificates();
 
     foreach (const BlackBerryCertificate *certificate, certificates)
         m_ui->keystore->addItem(certificate->fileName());

src/plugins/qnx/blackberrydeviceconnection.cpp

@@ -32,6 +32,7 @@
 #include "blackberrydeviceconnection.h"
 
 #include "blackberryconfiguration.h"
+#include "blackberryconfigurationmanager.h"
 #include "qnxutils.h"
 
 #include <projectexplorer/devicesupport/devicemanager.h>
@@ -61,7 +62,11 @@ BlackBerryDeviceConnection::BlackBerryDeviceConnection() :
 void BlackBerryDeviceConnection::connectDevice(const ProjectExplorer::IDevice::ConstPtr &device)
 {
     Utils::Environment env = Utils::Environment::systemEnvironment();
-    QnxUtils::prependQnxMapToEnvironment(BlackBerryConfiguration::instance().qnxEnv(), env);
+
+    QMultiMap<QString, QString> qnxEnv = BlackBerryConfigurationManager::instance().defaultQnxEnv();
+    if (!qnxEnv.isEmpty())
+        QnxUtils::prependQnxMapToEnvironment(qnxEnv, env);
+
     m_process->setEnvironment(env.toStringList());
 
     m_host = device->sshParameters().host;

src/plugins/qnx/blackberrykeyswidget.cpp

@@ -31,7 +31,7 @@
 
 #include "blackberrykeyswidget.h"
 #include "blackberryregisterkeydialog.h"
-#include "blackberryconfiguration.h"
+#include "blackberryconfigurationmanager.h"
 #include "blackberrycertificatemodel.h"
 #include "blackberryimportcertificatedialog.h"
 #include "blackberrycreatecertificatedialog.h"
@@ -75,9 +75,9 @@ BlackBerryKeysWidget::BlackBerryKeysWidget(QWidget *parent) :
 
 void BlackBerryKeysWidget::apply()
 {
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+    BlackBerryConfigurationManager &configManager = BlackBerryConfigurationManager::instance();
 
-    configuration.syncCertificates(m_model->certificates(), m_model->activeCertificate());
+    configManager.syncCertificates(m_model->certificates(), m_model->activeCertificate());
 }
 
 void BlackBerryKeysWidget::registerKey()
@@ -109,12 +109,12 @@ void BlackBerryKeysWidget::unregisterKey()
     if (answer & QMessageBox::No)
         return;
 
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+    BlackBerryConfigurationManager &configManager = BlackBerryConfigurationManager::instance();
 
-    QFile f(configuration.barsignerCskPath());
+    QFile f(configManager.barsignerCskPath());
     f.remove();
 
-    f.setFileName(configuration.barsignerDbPath());
+    f.setFileName(configManager.barsignerDbPath());
     f.remove();
 
     updateRegisterSection();

src/plugins/qnx/blackberryndkprocess.cpp

@@ -31,6 +31,7 @@
 
 #include "blackberryndkprocess.h"
 #include "blackberryconfiguration.h"
+#include "blackberryconfigurationmanager.h"
 
 #include <utils/hostosinfo.h>
 
@@ -54,12 +55,15 @@ BlackBerryNdkProcess::BlackBerryNdkProcess(const QString &command, QObject *pare
 
 QString BlackBerryNdkProcess::command() const
 {
-    QString command = BlackBerryConfiguration::instance()
-        .qnxEnv().value(QLatin1String("QNX_HOST"))
-        + (QLatin1String("/usr/bin/")) + m_command;
+    QString command;
+    QMultiMap<QString, QString> qnxEnv = BlackBerryConfigurationManager::instance().defaultQnxEnv();
+    if (!qnxEnv.isEmpty()) {
+        command = qnxEnv.value(QLatin1String("QNX_HOST"))
+                + (QLatin1String("/usr/bin/")) + m_command;
 
-    if (Utils::HostOsInfo::isWindowsHost())
-        command += QLatin1String(".bat");
+        if (Utils::HostOsInfo::isWindowsHost())
+            command += QLatin1String(".bat");
+    }
 
     return command;
 }

src/plugins/qnx/blackberryndksettingswidget.cpp

@@ -35,36 +35,40 @@
 #include "blackberryutils.h"
 #include "blackberrysetupwizard.h"
 
+#include "blackberryconfigurationmanager.h"
+#include "blackberryconfiguration.h"
+
 #include <utils/pathchooser.h>
 
 #include <coreplugin/icore.h>
 
 #include <QMessageBox>
+#include <QFileDialog>
+
+#include <QStandardItemModel>
+#include <QTreeWidgetItem>
 
 namespace Qnx {
 namespace Internal {
 
 BlackBerryNDKSettingsWidget::BlackBerryNDKSettingsWidget(QWidget *parent) :
     QWidget(parent),
-    m_ui(new Ui_BlackBerryNDKSettingsWidget)
+    m_ui(new Ui_BlackBerryNDKSettingsWidget),
+    m_autoDetectedNdks(0),
+    m_manualNdks(0)
 {
-    m_bbConfig = &BlackBerryConfiguration::instance();
+    m_bbConfigManager = &BlackBerryConfigurationManager::instance();
     m_ui->setupUi(this);
-    m_ui->sdkPath->setExpectedKind(Utils::PathChooser::ExistingDirectory);
-    m_ui->sdkPath->setPath(m_bbConfig->ndkPath());
-    m_hasValidSdkPath = QnxUtils::isValidNdkPath(m_ui->sdkPath->path());
+
+    m_ui->removeNdkButton->setEnabled(false);
 
     initInfoTable();
+    initNdkList();
 
     connect(m_ui->wizardButton, SIGNAL(clicked()), this, SLOT(launchBlackBerrySetupWizard()));
-    connect(m_ui->sdkPath, SIGNAL(changed(QString)), this, SLOT(checkSdkPath()));
-    connect(m_ui->removeButton, SIGNAL(clicked()), this, SLOT(cleanConfiguration()));
-    connect(m_bbConfig, SIGNAL(updated()), this, SLOT(updateInfoTable()));
-}
-
-void BlackBerryNDKSettingsWidget::setRemoveButtonVisible(bool visible)
-{
-    m_ui->removeButton->setVisible(visible);
+    connect(m_ui->addNdkButton, SIGNAL(clicked()), this, SLOT(addNdk()));
+    connect(m_ui->removeNdkButton, SIGNAL(clicked()), this, SLOT(removeNdk()));
+    connect(m_ui->ndksTreeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), this, SLOT(updateInfoTable(QTreeWidgetItem*)));
 }
 
 void BlackBerryNDKSettingsWidget::setWizardMessageVisible(bool visible)
@@ -73,9 +77,9 @@ void BlackBerryNDKSettingsWidget::setWizardMessageVisible(bool visible)
     m_ui->wizardButton->setVisible(visible);
 }
 
-QString BlackBerryNDKSettingsWidget::sdkPath() const
+bool BlackBerryNDKSettingsWidget::hasActiveNdk() const
 {
-    return m_ui->sdkPath->path();
+    return !m_bbConfigManager->configurations().isEmpty();
 }
 
 void BlackBerryNDKSettingsWidget::launchBlackBerrySetupWizard() const
@@ -92,30 +96,16 @@ void BlackBerryNDKSettingsWidget::launchBlackBerrySetupWizard() const
     wizard.exec();
 }
 
-void BlackBerryNDKSettingsWidget::checkSdkPath()
+void BlackBerryNDKSettingsWidget::updateInfoTable(QTreeWidgetItem* currentNdk)
 {
-    if (!m_ui->sdkPath->path().isEmpty() &&
-            QnxUtils::isValidNdkPath(m_ui->sdkPath->path())) {
-        m_bbConfig->setupNdkConfiguration(m_ui->sdkPath->path());
-        m_hasValidSdkPath = true;
-    } else {
-        m_hasValidSdkPath = false;
+    QString ndkPath = currentNdk->text(1);
+    if (ndkPath.isEmpty()) {
+        m_ui->removeNdkButton->setEnabled(false);
+        return;
     }
 
-    emit sdkPathChanged(m_ui->sdkPath->path());
-}
-
-bool BlackBerryNDKSettingsWidget::hasValidSdkPath() const
-{
-    return m_hasValidSdkPath;
-}
-
-void BlackBerryNDKSettingsWidget::updateInfoTable()
-{
-    QMultiMap<QString, QString> env = m_bbConfig->qnxEnv();
-
+    QMultiMap<QString, QString> env = QnxUtils::parseEnvironmentFile(QnxUtils::envFilePath(ndkPath));
     if (env.isEmpty()) {
-        // clear
         clearInfoTable();
         return;
     }
@@ -137,30 +127,83 @@ void BlackBerryNDKSettingsWidget::updateInfoTable()
         m_infoModel->appendRow(row);
     }
 
-    m_infoModel->appendRow( QList<QStandardItem*>() << new QStandardItem(QString(QLatin1String("QMAKE 4"))) << new QStandardItem(m_bbConfig->qmake4Path().toString()));
-    m_infoModel->appendRow( QList<QStandardItem*>() << new QStandardItem(QString(QLatin1String("QMAKE 5"))) << new QStandardItem(m_bbConfig->qmake5Path().toString()));
-    m_infoModel->appendRow( QList<QStandardItem*>() << new QStandardItem(QString(QLatin1String("COMPILER"))) << new QStandardItem(m_bbConfig->gccPath().toString()));
+    BlackBerryConfiguration *config = m_bbConfigManager->configurationFromNdkPath(ndkPath);
+    if (!config)
+        return;
 
-    m_ui->removeButton->setEnabled(true);
+    QString qmake4Path = config->qmake4BinaryFile().toString();
+    QString qmake5Path = config->qmake5BinaryFile().toString();
+
+    if (!qmake4Path.isEmpty())
+        m_infoModel->appendRow(QList<QStandardItem*>() << new QStandardItem(QString(QLatin1String("QMAKE 4"))) << new QStandardItem(qmake4Path));
+
+    if (!qmake5Path.isEmpty())
+        m_infoModel->appendRow(QList<QStandardItem*>() << new QStandardItem(QString(QLatin1String("QMAKE 5"))) << new QStandardItem(qmake5Path));
+
+    m_infoModel->appendRow(QList<QStandardItem*>() << new QStandardItem(QString(QLatin1String("COMPILER"))) << new QStandardItem(config->gccCompiler().toString()));
+
+    m_ui->removeNdkButton->setEnabled(!config->isAutoDetected());
+}
+
+void BlackBerryNDKSettingsWidget::updateNdkList()
+{
+    foreach (BlackBerryConfiguration *config, m_bbConfigManager->configurations()) {
+        QTreeWidgetItem *parent = config->isAutoDetected() ? m_autoDetectedNdks : m_manualNdks;
+        QTreeWidgetItem *item = new QTreeWidgetItem(parent);
+        item->setText(0, config->displayName());
+        item->setText(1, config->ndkPath()); // TODO: should be target name for NDKs >= v10.2
+    }
+
+    if (m_autoDetectedNdks->child(0)) {
+        m_autoDetectedNdks->child(0)->setSelected(true);
+        updateInfoTable(m_autoDetectedNdks->child(0));
+    }
 }
 
 void BlackBerryNDKSettingsWidget::clearInfoTable()
 {
     m_infoModel->clear();
-    m_ui->sdkPath->setPath(QString());
-    m_ui->removeButton->setEnabled(false);
 }
 
-void BlackBerryNDKSettingsWidget::cleanConfiguration()
+void BlackBerryNDKSettingsWidget::addNdk()
 {
+    QString selectedPath = QFileDialog::getExistingDirectory(0, tr("Select the NDK path"),
+                                                             QString(),
+                                                             QFileDialog::ShowDirsOnly);
+    if (selectedPath.isEmpty())
+        return;
+
+    BlackBerryConfiguration *config = m_bbConfigManager->configurationFromNdkPath(selectedPath);
+    if (!config) {
+        config = new BlackBerryConfiguration(selectedPath, false);
+        if (!m_bbConfigManager->addConfiguration(config)) {
+            delete config;
+            return;
+        }
+
+        QTreeWidgetItem *item = new QTreeWidgetItem(m_manualNdks);
+        item->setText(0, selectedPath.split(QDir::separator()).last());
+        item->setText(1, selectedPath);
+        updateInfoTable(item);
+    }
+}
+
+void BlackBerryNDKSettingsWidget::removeNdk()
+{
+    QString ndkPath = m_ui->ndksTreeWidget->currentItem()->text(1);
     QMessageBox::StandardButton button =
             QMessageBox::question(Core::ICore::mainWindow(),
                                   tr("Clean BlackBerry 10 Configuration"),
-                                  tr("Are you sure you want to remove the current BlackBerry configuration?"),
+                                  tr("Are you sure you want to remove:\n %1?").arg(ndkPath),
                                   QMessageBox::Yes | QMessageBox::No);
 
-    if (button == QMessageBox::Yes)
-        m_bbConfig->cleanNdkConfiguration();
+    if (button == QMessageBox::Yes) {
+        BlackBerryConfiguration *config = m_bbConfigManager->configurationFromNdkPath(ndkPath);
+        if (config)
+            m_bbConfigManager->removeConfiguration(config);
+            m_manualNdks->removeChild(m_ui->ndksTreeWidget->currentItem());
+    }
+
 }
 
 void BlackBerryNDKSettingsWidget::initInfoTable()
@@ -170,8 +213,27 @@ void BlackBerryNDKSettingsWidget::initInfoTable()
     m_ui->ndkInfosTableView->setModel(m_infoModel);
     m_ui->ndkInfosTableView->verticalHeader()->hide();
     m_ui->ndkInfosTableView->setEditTriggers(QAbstractItemView::NoEditTriggers);
+}
 
-    updateInfoTable();
+void BlackBerryNDKSettingsWidget::initNdkList()
+{
+    m_ui->ndksTreeWidget->header()->setResizeMode(QHeaderView::Stretch);
+    m_ui->ndksTreeWidget->header()->setStretchLastSection(false);
+    m_ui->ndksTreeWidget->setHeaderItem(new QTreeWidgetItem(QStringList() << tr("NDK") << tr("Path")));
+    m_ui->ndksTreeWidget->setTextElideMode(Qt::ElideNone);
+    m_ui->ndksTreeWidget->setColumnCount(2);
+    m_autoDetectedNdks = new QTreeWidgetItem(m_ui->ndksTreeWidget);
+    m_autoDetectedNdks->setText(0, tr("Auto-Detected"));
+    m_autoDetectedNdks->setFirstColumnSpanned(true);
+    m_autoDetectedNdks->setFlags(Qt::ItemIsEnabled);
+    m_manualNdks = new QTreeWidgetItem(m_ui->ndksTreeWidget);
+    m_manualNdks->setText(0, tr("Manual"));
+    m_manualNdks->setFirstColumnSpanned(true);
+    m_manualNdks->setFlags(Qt::ItemIsEnabled);
+
+    m_ui->ndksTreeWidget->expandAll();
+
+    updateNdkList();
 }
 
 } // namespace Internal

src/plugins/qnx/blackberryndksettingswidget.h

@@ -32,48 +32,47 @@
 #ifndef BLACKBERRYNDKSETTINGSWIDGET_H
 #define BLACKBERRYNDKSETTINGSWIDGET_H
 
-#include "blackberryconfiguration.h"
-
 #include <QWidget>
-#include <QStandardItemModel>
 
+class QStandardItemModel;
+class QTreeWidgetItem;
 
 namespace Qnx {
 namespace Internal {
 
+class BlackBerryConfigurationManager;
 class Ui_BlackBerryNDKSettingsWidget;
 
-
 class BlackBerryNDKSettingsWidget : public QWidget
 {
     Q_OBJECT
 public:
     explicit BlackBerryNDKSettingsWidget(QWidget *parent = 0);
 
-   void setRemoveButtonVisible(bool visible);
    void setWizardMessageVisible(bool visible);
 
-   QString sdkPath() const;
-
-   bool hasValidSdkPath() const;
+   bool hasActiveNdk() const;
 
 signals:
-    void sdkPathChanged(const QString &newPath);
+    void kitsUpdated();
 
 public slots:
     void launchBlackBerrySetupWizard() const;
-    void checkSdkPath();
-    void updateInfoTable();
+    void updateInfoTable(QTreeWidgetItem* currentNdk);
+    void updateNdkList();
     void clearInfoTable();
-    void cleanConfiguration();
+    void addNdk();
+    void removeNdk();
 
 private:
     void initInfoTable();
-    Ui_BlackBerryNDKSettingsWidget *m_ui;
-    BlackBerryConfiguration *m_bbConfig;
-    QStandardItemModel *m_infoModel;
-    bool m_hasValidSdkPath;
+    void initNdkList();
 
+    Ui_BlackBerryNDKSettingsWidget *m_ui;
+    BlackBerryConfigurationManager *m_bbConfigManager;
+    QStandardItemModel *m_infoModel;
+    QTreeWidgetItem *m_autoDetectedNdks;
+    QTreeWidgetItem *m_manualNdks;
 };
 
 } // namespace Internal

src/plugins/qnx/blackberryndksettingswidget.ui

@@ -150,39 +150,41 @@
      <item row="0" column="0">
       <layout class="QHBoxLayout" name="horizontalLayout_2">
        <item>
-        <widget class="QLabel" name="label">
-         <property name="text">
-          <string>BlackBerry NDK Path </string>
-         </property>
+        <widget class="QTreeWidget" name="ndksTreeWidget">
+         <column>
+          <property name="text">
+           <string notr="true">1</string>
+          </property>
+         </column>
         </widget>
        </item>
        <item>
-        <widget class="Utils::PathChooser" name="sdkPath" native="true"/>
+        <layout class="QVBoxLayout" name="verticalLayout_2">
+         <item>
+          <widget class="QPushButton" name="addNdkButton">
+           <property name="text">
+            <string>Add NDK</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QPushButton" name="removeNdkButton">
+           <property name="text">
+            <string>Remove NDK</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
        </item>
       </layout>
      </item>
-     <item row="0" column="1">
-      <widget class="QPushButton" name="removeButton">
-       <property name="text">
-        <string>Remove</string>
-       </property>
-      </widget>
-     </item>
-     <item row="1" column="0">
+     <item row="2" column="0">
       <widget class="QTableView" name="ndkInfosTableView"/>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
- <customwidgets>
-  <customwidget>
-   <class>Utils::PathChooser</class>
-   <extends>QWidget</extends>
-   <header location="global">utils/pathchooser.h</header>
-   <container>1</container>
-  </customwidget>
- </customwidgets>
  <resources/>
  <connections/>
 </ui>

src/plugins/qnx/blackberryregisterkeydialog.cpp

@@ -31,7 +31,7 @@
 
 #include "blackberryregisterkeydialog.h"
 #include "blackberrycsjregistrar.h"
-#include "blackberryconfiguration.h"
+#include "blackberryconfigurationmanager.h"
 #include "blackberrycertificate.h"
 #include "blackberryutils.h"
 #include "ui_blackberryregisterkeydialog.h"
@@ -69,7 +69,7 @@ BlackBerryRegisterKeyDialog::BlackBerryRegisterKeyDialog(QWidget *parent,
 
     m_okButton->setEnabled(false);
 
-    QFileInfo authorP12(BlackBerryConfiguration::instance().defaultKeystorePath());
+    QFileInfo authorP12(BlackBerryConfigurationManager::instance().defaultKeystorePath());
 
     if (authorP12.exists()) {
         m_ui->genCert->setEnabled(false);
@@ -259,8 +259,8 @@ QString BlackBerryRegisterKeyDialog::keystorePassword() const
 QString BlackBerryRegisterKeyDialog::keystorePath() const
 {
     if (m_ui->genCert->isChecked()) {
-        BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
-        return configuration.defaultKeystorePath();
+        BlackBerryConfigurationManager &configManager = BlackBerryConfigurationManager::instance();
+        return configManager.defaultKeystorePath();
     }
 
     return QString();
@@ -283,7 +283,7 @@ void BlackBerryRegisterKeyDialog::generateDeveloperCertificate()
 
 void BlackBerryRegisterKeyDialog::cleanup() const
 {
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+    BlackBerryConfigurationManager &configuration = BlackBerryConfigurationManager::instance();
 
     QFile f(configuration.barsignerCskPath());
     f.remove();

src/plugins/qnx/blackberrysetupwizard.cpp

@@ -34,7 +34,7 @@
 #include "blackberrydeviceconfiguration.h"
 #include "blackberrycsjregistrar.h"
 #include "blackberrycertificate.h"
-#include "blackberryconfiguration.h"
+#include "blackberryconfigurationmanager.h"
 #include "blackberrydebugtokenrequester.h"
 #include "blackberrydebugtokenuploader.h"
 #include "blackberrydeviceinformation.h"
@@ -185,8 +185,8 @@ void BlackBerrySetupWizard::certificateCreated(int status)
         return;
     }
 
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
-    configuration.addCertificate(m_certificate);
+    BlackBerryConfigurationManager &configManager = BlackBerryConfigurationManager::instance();
+    configManager.addCertificate(m_certificate);
 
     emit stepFinished();
 }
@@ -297,7 +297,7 @@ void BlackBerrySetupWizard::setBusy(bool busy)
 
 void BlackBerrySetupWizard::cleanupFiles() const
 {
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+    BlackBerryConfigurationManager &configuration = BlackBerryConfigurationManager::instance();
 
     QFile f(configuration.barsignerCskPath());
     f.remove();
@@ -327,7 +327,7 @@ void BlackBerrySetupWizard::reset()
     m_currentStep = -1;
 
     if (m_certificate) {
-        BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+        BlackBerryConfigurationManager &configuration = BlackBerryConfigurationManager::instance();
         configuration.removeCertificate(m_certificate);
         m_certificate = 0;
     }
@@ -353,7 +353,7 @@ void BlackBerrySetupWizard::createKeys()
 
 void BlackBerrySetupWizard::generateDeveloperCertificate()
 {
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+    BlackBerryConfigurationManager &configuration = BlackBerryConfigurationManager::instance();
 
     m_certificate = new BlackBerryCertificate(configuration.defaultKeystorePath(),
             BlackBerryUtils::getCsjAuthor(rdkPath()), password());
@@ -430,7 +430,7 @@ void BlackBerrySetupWizard::requestDebugToken()
         return;
     }
 
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+    BlackBerryConfigurationManager &configuration = BlackBerryConfigurationManager::instance();
 
     m_requester->requestDebugToken(configuration.defaultDebugTokenPath(),
             password(), configuration.defaultKeystorePath(), password(), m_devicePin);
@@ -443,7 +443,7 @@ void BlackBerrySetupWizard::uploadDebugToken()
         return;
     }
 
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+    BlackBerryConfigurationManager &configuration = BlackBerryConfigurationManager::instance();
 
     m_uploader->uploadDebugToken(configuration.defaultDebugTokenPath(),
             hostName(), devicePassword());
@@ -530,7 +530,7 @@ IDevice::Ptr BlackBerrySetupWizard::device()
             deviceName(), Core::Id(Constants::QNX_BB_OS_TYPE), machineType);
 
     configuration->setSshParameters(sshParams);
-    configuration->setDebugToken(BlackBerryConfiguration::instance().defaultDebugTokenPath());
+    configuration->setDebugToken(BlackBerryConfigurationManager::instance().defaultDebugTokenPath());
 
     return configuration;
 }

src/plugins/qnx/blackberrysetupwizardpages.cpp

@@ -83,9 +83,8 @@ BlackBerrySetupWizardNdkPage::BlackBerrySetupWizardNdkPage(QWidget *parent) :
 
     m_widget = new BlackBerryNDKSettingsWidget(this);
     m_widget->setWizardMessageVisible(false);
-    m_widget->setRemoveButtonVisible(false);
 
-    connect(m_widget, SIGNAL(sdkPathChanged(QString)), this, SIGNAL(completeChanged()));
+    connect(m_widget, SIGNAL(kitsUpdated()), this, SIGNAL(completeChanged()));
 
     QVBoxLayout *layout = new QVBoxLayout;
     layout->addWidget(m_widget);
@@ -99,7 +98,7 @@ BlackBerrySetupWizardNdkPage::~BlackBerrySetupWizardNdkPage()
 
 bool BlackBerrySetupWizardNdkPage::isComplete() const
 {
-    return m_widget->hasValidSdkPath();
+    return m_widget->hasActiveNdk();
 }
 
 //-----------------------------------------------------------------------------

src/plugins/qnx/blackberryutils.cpp

@@ -31,6 +31,7 @@
 
 #include "blackberryutils.h"
 #include "blackberryconfiguration.h"
+#include "blackberryconfigurationmanager.h"
 
 #include <QFileInfo>
 #include <QString>
@@ -41,7 +42,7 @@ using namespace Qnx::Internal;
 
 bool BlackBerryUtils::hasRegisteredKeys()
 {
-    BlackBerryConfiguration &configuration = BlackBerryConfiguration::instance();
+    BlackBerryConfigurationManager &configuration = BlackBerryConfigurationManager::instance();
 
     QFileInfo cskFile(configuration.barsignerCskPath());
 

src/plugins/qnx/qnx.pro

@@ -93,7 +93,8 @@ SOURCES += qnxplugin.cpp \
     blackberrysetupwizard.cpp \
     blackberrysetupwizardpages.cpp \
     blackberryutils.cpp \
-    qnxdevicetester.cpp
+    qnxdevicetester.cpp \
+    blackberryconfigurationmanager.cpp
 
 HEADERS += qnxplugin.h\
     qnxconstants.h \
@@ -186,7 +187,8 @@ HEADERS += qnxplugin.h\
     blackberrysetupwizard.h \
     blackberrysetupwizardpages.h \
     blackberryutils.h \
-    qnxdevicetester.h
+    qnxdevicetester.h \
+    blackberryconfigurationmanager.h
 
 FORMS += \
     blackberrydeviceconfigurationwizardsetuppage.ui \

src/plugins/qnx/qnxplugin.cpp

@@ -51,11 +51,13 @@
 #include "blackberrykeyspage.h"
 #include "blackberrycheckdevmodestepfactory.h"
 #include "blackberrydeviceconnectionmanager.h"
+#include "blackberryconfigurationmanager.h"
 
 #include <coreplugin/icore.h>
 #include <coreplugin/mimedatabase.h>
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/taskhub.h>
+#include <projectexplorer/kitmanager.h>
 
 #include <QtPlugin>
 
@@ -68,6 +70,7 @@ QNXPlugin::QNXPlugin()
 QNXPlugin::~QNXPlugin()
 {
     delete BlackBerryDeviceConnectionManager::instance();
+    delete &BlackBerryConfigurationManager::instance();
 }
 
 bool QNXPlugin::initialize(const QStringList &arguments, QString *errorString)
@@ -111,6 +114,8 @@ bool QNXPlugin::initialize(const QStringList &arguments, QString *errorString)
     }
     addAutoReleasedObject(new BarDescriptorEditorFactory);
 
+    connect(ProjectExplorer::KitManager::instance(), SIGNAL(kitsLoaded()), &BlackBerryConfigurationManager::instance(), SLOT(loadSettings()));
+
     return true;
 }
 

src/plugins/qnx/qnxutils.cpp

@@ -262,9 +262,20 @@ QString QnxUtils::qConfigPath()
 
 QString QnxUtils::ndkVersion(const QString &ndkPath)
 {
+    foreach (const NdkInstallInformation &ndkInfo, installedNdks()) {
+        if (!ndkInfo.path.compare(ndkPath, Utils::HostOsInfo::fileNameCaseSensitivity()))
+            return ndkInfo.version;
+    }
+
+    return QString();
+}
+
+QList<NdkInstallInformation> QnxUtils::installedNdks()
+{
+    QList<NdkInstallInformation> ndkList;
     QString ndkConfigPath = qConfigPath();
     if (!QDir(ndkConfigPath).exists())
-        return QString();
+        return ndkList;
 
     QFileInfoList ndkfileList = QDir(ndkConfigPath).entryInfoList(QStringList() << QLatin1String("*.xml"),
                                                                   QDir::Files, QDir::Time);
@@ -285,11 +296,16 @@ QString QnxUtils::ndkVersion(const QString &ndkPath)
         // The file contains only one installation node
         if (!childElt.isNull()) {
             // The file contains only one base node
-            QDomElement elt = childElt.firstChildElement(QLatin1String("base"));
-            if (!elt.text().compare(ndkPath, Utils::HostOsInfo::fileNameCaseSensitivity()))
-                return childElt.firstChildElement(QLatin1String("version")).text();
+            NdkInstallInformation ndkInfo;
+            ndkInfo.path = childElt.firstChildElement(QLatin1String("base")).text();
+            ndkInfo.name = childElt.firstChildElement(QLatin1String("name")).text();
+            ndkInfo.host = childElt.firstChildElement(QLatin1String("host")).text();
+            ndkInfo.target = childElt.firstChildElement(QLatin1String("target")).text();
+            ndkInfo.version = childElt.firstChildElement(QLatin1String("version")).text();
+
+            ndkList.append(ndkInfo);
         }
     }
 
-    return QString();
+    return ndkList;
 }

src/plugins/qnx/qnxutils.h

@@ -46,6 +46,16 @@ namespace Internal {
 
 class QnxAbstractQtVersion;
 
+class NdkInstallInformation
+{
+public:
+    QString path;
+    QString name;
+    QString host;
+    QString target;
+    QString version;
+};
+
 class QnxUtils
 {
 public:
@@ -60,6 +70,7 @@ public:
     static QString dataDirPath();
     static QString qConfigPath();
     static QString ndkVersion(const QString& ndkPath);
+    static QList<NdkInstallInformation> installedNdks();
 };
 
 } // namespace Internal