Introduce the concept of an abstract device.

The idea is that all kinds of devices inherit from one abstract base class and that they are all managed by one device manager, who does not know about their specifics. For now, the only concrete subclass is the LinuxDeviceConguration. Change-Id: I31ff5586a0fdd6bcf8dcc0554bb2b91fe65b2f3f Reviewed-by: Kai Koehne <kai.koehne@nokia.com>
2012-03-06 12:31:42 +01:00
parent 933592e6a7
commit 9a34b156c1
52 changed files with 1432 additions and 1189 deletions
@@ -31,9 +31,8 @@
 #include "sshkeycreationdialog.h"
 #include "ui_sshkeycreationdialog.h"

-#include "linuxdeviceconfiguration.h"
+#include "sshkeygenerator.h"

-#include <utils/ssh/sshkeygenerator.h>
 #include <utils/fileutils.h>

 #include <QDir>
@@ -43,8 +42,7 @@
 #include <QDesktopServices>
 #include <QMessageBox>

-using namespace Utils;
-using namespace RemoteLinux::Internal;
+namespace Utils {

 SshKeyCreationDialog::SshKeyCreationDialog(QWidget *parent)
    : QDialog(parent), m_keyGenerator(0), m_ui(new Ui::SshKeyCreationDialog)
@@ -115,7 +113,7 @@ void SshKeyCreationDialog::saveKeys()
        return;
    QFile::setPermissions(privateKeyFilePath(), QFile::ReadOwner | QFile::WriteOwner);

-    FileSaver pubSaver(m_ui->publicKeyFileLabel->text());
+    FileSaver pubSaver(publicKeyFilePath());
    pubSaver.write(m_keyGenerator->publicKey());
    if (pubSaver.finalize(this))
        accept();
@@ -125,3 +123,10 @@ QString SshKeyCreationDialog::privateKeyFilePath() const
 {
    return m_ui->privateKeyFilePathChooser->path();
 }
+
+QString SshKeyCreationDialog::publicKeyFilePath() const
+{
+    return m_ui->publicKeyFileLabel->text();
+}
+
+} // namespace Utils
@@ -32,25 +32,25 @@
 #ifndef SSHKEYCREATIONDIALOG_H
 #define SSHKEYCREATIONDIALOG_H

+#include <utils/utils_global.h>
+
 #include <QDialog>

 namespace Utils {
 class SshKeyGenerator;
-}

-namespace RemoteLinux {
-namespace Internal {
-namespace Ui {
-class SshKeyCreationDialog;
-}
+namespace Ui { class SshKeyCreationDialog; }

-class SshKeyCreationDialog : public QDialog
+class QTCREATOR_UTILS_EXPORT SshKeyCreationDialog : public QDialog
 {
    Q_OBJECT
 public:
    SshKeyCreationDialog(QWidget *parent = 0);
    ~SshKeyCreationDialog();

+    QString privateKeyFilePath() const;
+    QString publicKeyFilePath() const;
+
 private slots:
    void keyTypeChanged();
    void generateKeys();
@@ -58,14 +58,12 @@ private slots:

 private:
    void saveKeys();
-    QString privateKeyFilePath() const;

 private:
-    Utils::SshKeyGenerator *m_keyGenerator;
+    SshKeyGenerator *m_keyGenerator;
    Ui::SshKeyCreationDialog *m_ui;
 };

-} // namespace Internal
-} // namespace RemoteLinux
+} // namespace Utils

 #endif  // SSHKEYCREATIONDIALOG_H
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>RemoteLinux::Internal::SshKeyCreationDialog</class>
- <widget class="QDialog" name="RemoteLinux::Internal::SshKeyCreationDialog">
+ <class>Utils::SshKeyCreationDialog</class>
+ <widget class="QDialog" name="Utils::SshKeyCreationDialog">
  <property name="enabled">
   <bool>true</bool>
  </property>
@@ -234,7 +234,7 @@
  <connection>
   <sender>closeButton</sender>
   <signal>clicked()</signal>
-   <receiver>RemoteLinux::Internal::SshKeyCreationDialog</receiver>
+   <receiver>Utils::SshKeyCreationDialog</receiver>
   <slot>close()</slot>
   <hints>
    <hint type="sourcelabel">
@@ -88,6 +88,7 @@ SOURCES += $$PWD/environment.cpp \
    $$PWD/ssh/sshconnectionmanager.cpp \
    $$PWD/ssh/sshkeypasswordretriever.cpp \
    $$PWD/ssh/sftpfilesystemmodel.cpp \
+    $$PWD/ssh/sshkeycreationdialog.cpp \
    $$PWD/outputformatter.cpp \
    $$PWD/flowlayout.cpp \
    $$PWD/networkaccessmanager.cpp \
@@ -196,6 +197,7 @@ HEADERS += \
    $$PWD/ssh/sshpseudoterminal.h \
    $$PWD/ssh/sshkeypasswordretriever_p.h \
    $$PWD/ssh/sftpfilesystemmodel.h \
+    $$PWD/ssh/sshkeycreationdialog.h \
    $$PWD/statuslabel.h \
    $$PWD/outputformatter.h \
    $$PWD/outputformat.h \
@@ -212,6 +214,7 @@ HEADERS += \
 FORMS += $$PWD/filewizardpage.ui \
    $$PWD/projectintropage.ui \
    $$PWD/newclasswidget.ui \
-    $$PWD/submiteditorwidget.ui
+    $$PWD/submiteditorwidget.ui \
+    $$PWD/ssh/sshkeycreationdialog.ui

 RESOURCES += $$PWD/utils.qrc
@@ -219,7 +219,10 @@ DynamicLibrary {
        "ssh/sshconnection.cpp",
        "ssh/sshincomingpacket.cpp",
        "ssh/sshkeygenerator.cpp",
-        "ssh/sshkeygenerator.h"
+        "ssh/sshkeygenerator.h",
+        "ssh/sshkeycreationdialog.cpp",
+        "ssh/sshkeycreationdialog.h",
+        "ssh/sshkeycreationdialog.ui"
    ]

    Group {
@@ -43,6 +43,7 @@
 #include <remotelinux/genericlinuxdeviceconfigurationwidget.h>
 #include <utils/qtcassert.h>

+using namespace ProjectExplorer;
 using namespace RemoteLinux;

 namespace Madde {
@@ -53,7 +54,7 @@ const char MaddeRemoteProcessesActionId[] = "Madde.RemoteProcessesAction";
 } // anonymous namespace

 MaddeDeviceConfigurationFactory::MaddeDeviceConfigurationFactory(QObject *parent)
-    : ILinuxDeviceConfigurationFactory(parent)
+    : IDeviceFactory(parent)
 {
 }

@@ -62,16 +63,25 @@ QString MaddeDeviceConfigurationFactory::displayName() const
    return tr("Device with MADDE support (Fremantle, Harmattan, MeeGo)");
 }

-ILinuxDeviceConfigurationWizard *MaddeDeviceConfigurationFactory::createWizard(QWidget *parent) const
+IDeviceWizard *MaddeDeviceConfigurationFactory::createWizard(QWidget *parent) const
 {
    return new MaemoDeviceConfigWizard(parent);
 }

-ILinuxDeviceConfigurationWidget *MaddeDeviceConfigurationFactory::createWidget(
-        const LinuxDeviceConfiguration::Ptr &deviceConfig,
+IDeviceWidget *MaddeDeviceConfigurationFactory::createWidget(const IDevice::Ptr &device,
        QWidget *parent) const
 {
-    return new GenericLinuxDeviceConfigurationWidget(deviceConfig, parent);
+    return new GenericLinuxDeviceConfigurationWidget(device.staticCast<LinuxDeviceConfiguration>(),
+        parent);
+}
+
+IDevice::Ptr MaddeDeviceConfigurationFactory::loadDevice(const QVariantMap &map) const
+{
+    QTC_ASSERT(supportsDeviceType(IDevice::typeFromMap(map)),
+        return LinuxDeviceConfiguration::Ptr());
+    LinuxDeviceConfiguration::Ptr device = LinuxDeviceConfiguration::create();
+    device->fromMap(map);
+    return device;
 }

 bool MaddeDeviceConfigurationFactory::supportsDeviceType(const QString &type) const
@@ -80,7 +90,7 @@ bool MaddeDeviceConfigurationFactory::supportsDeviceType(const QString &type) co
        || type == QLatin1String(MeeGoOsType);
 }

-QString MaddeDeviceConfigurationFactory::displayType(const QString &deviceType) const
+QString MaddeDeviceConfigurationFactory::displayNameForDeviceType(const QString &deviceType) const
 {
    QTC_ASSERT(supportsDeviceType(deviceType), return QString());
    if (deviceType == QLatin1String(Maemo5OsType))
@@ -111,16 +121,18 @@ QString MaddeDeviceConfigurationFactory::displayNameForActionId(const QString &a
 }

 QDialog *MaddeDeviceConfigurationFactory::createDeviceAction(const QString &actionId,
-    const LinuxDeviceConfiguration::ConstPtr &deviceConfig, QWidget *parent) const
+    const IDevice::ConstPtr &device, QWidget *parent) const
 {
    Q_ASSERT(supportedDeviceActionIds().contains(actionId));

+    const LinuxDeviceConfiguration::ConstPtr lDevice
+        = device.staticCast<const LinuxDeviceConfiguration>();
    if (actionId == QLatin1String(MaddeDeviceTestActionId))
-        return new LinuxDeviceTestDialog(deviceConfig, new MaddeDeviceTester, parent);
+        return new LinuxDeviceTestDialog(lDevice, new MaddeDeviceTester, parent);
    if (actionId == QLatin1String(MaddeRemoteProcessesActionId))
-        return new RemoteLinuxProcessesDialog(new GenericRemoteLinuxProcessList(deviceConfig), parent);
+        return new RemoteLinuxProcessesDialog(new GenericRemoteLinuxProcessList(lDevice), parent);
    if (actionId == QLatin1String(Constants::GenericDeployKeyToDeviceActionId))
-        return PublicKeyDeploymentDialog::createDialog(deviceConfig, parent);
+        return PublicKeyDeploymentDialog::createDialog(lDevice, parent);
    return 0; // Can't happen.
 }

@@ -32,28 +32,28 @@
 #ifndef MADDEDEVICECONFIGURATIONFACTORY_H
 #define MADDEDEVICECONFIGURATIONFACTORY_H

-#include <remotelinux/linuxdeviceconfiguration.h>
+#include <projectexplorer/devicesupport/idevicefactory.h>

 namespace Madde {
 namespace Internal {

-class MaddeDeviceConfigurationFactory : public RemoteLinux::ILinuxDeviceConfigurationFactory
+class MaddeDeviceConfigurationFactory : public ProjectExplorer::IDeviceFactory
 {
    Q_OBJECT
 public:
    MaddeDeviceConfigurationFactory(QObject *parent = 0);

    QString displayName() const;
-    RemoteLinux::ILinuxDeviceConfigurationWizard *createWizard(QWidget *parent) const;
-    RemoteLinux::ILinuxDeviceConfigurationWidget *createWidget(
-            const RemoteLinux::LinuxDeviceConfiguration::Ptr &deviceConfig,
-            QWidget *parent = 0) const;
+    ProjectExplorer::IDeviceWizard *createWizard(QWidget *parent) const;
+    ProjectExplorer::IDeviceWidget *createWidget(
+        const ProjectExplorer::IDevice::Ptr &device, QWidget *parent = 0) const;
+    ProjectExplorer::IDevice::Ptr loadDevice(const QVariantMap &map) const;
    bool supportsDeviceType(const QString &type) const;
-    QString displayType(const QString &deviceType) const;
+    QString displayNameForDeviceType(const QString &deviceType) const;
    QStringList supportedDeviceActionIds() const;
    QString displayNameForActionId(const QString &actionId) const;
    QDialog *createDeviceAction(const QString &actionId,
-        const RemoteLinux::LinuxDeviceConfiguration::ConstPtr &deviceConfig, QWidget *parent) const;
+        const ProjectExplorer::IDevice::ConstPtr &device, QWidget *parent) const;
 };

 } // namespace Internal
@@ -40,9 +40,10 @@
 #include "maemoconstants.h"
 #include "maemoglobal.h"

+#include <projectexplorer/devicesupport/devicemanager.h>
 #include <remotelinux/genericlinuxdeviceconfigurationwizardpages.h>
+#include <remotelinux/linuxdeviceconfiguration.h>
 #include <remotelinux/linuxdevicetestdialog.h>
-#include <remotelinux/remotelinuxutils.h>
 #include <remotelinux/sshkeydeployer.h>
 #include <utils/fileutils.h>
 #include <utils/ssh/sshkeygenerator.h>
@@ -54,6 +55,7 @@
 #include <QMessageBox>
 #include <QWizardPage>

+using namespace ProjectExplorer;
 using namespace RemoteLinux;
 using namespace Utils;

@@ -104,11 +106,11 @@ public:
        setTitle(tr("General Information"));
        setSubTitle(QLatin1String(" ")); // For Qt bug (background color)

-        m_ui->osTypeComboBox->addItem(RemoteLinuxUtils::displayType(QLatin1String(Maemo5OsType)),
+        m_ui->osTypeComboBox->addItem(DeviceManager::displayNameForDeviceType(QLatin1String(Maemo5OsType)),
            QLatin1String(Maemo5OsType));
-        m_ui->osTypeComboBox->addItem(RemoteLinuxUtils::displayType(QLatin1String(HarmattanOsType)),
+        m_ui->osTypeComboBox->addItem(DeviceManager::displayNameForDeviceType(QLatin1String(HarmattanOsType)),
            QLatin1String(HarmattanOsType));
-        m_ui->osTypeComboBox->addItem(RemoteLinuxUtils::displayType(QLatin1String(MeeGoOsType)),
+        m_ui->osTypeComboBox->addItem(DeviceManager::displayNameForDeviceType(QLatin1String(MeeGoOsType)),
            QLatin1String(MeeGoOsType));

        QButtonGroup *buttonGroup = new QButtonGroup(this);
@@ -538,7 +540,7 @@ struct MaemoDeviceConfigWizardPrivate


 MaemoDeviceConfigWizard::MaemoDeviceConfigWizard(QWidget *parent)
-    : ILinuxDeviceConfigurationWizard(parent), d(new MaemoDeviceConfigWizardPrivate(this))
+    : IDeviceWizard(parent), d(new MaemoDeviceConfigWizardPrivate(this))
 {
    setWindowTitle(tr("New Device Configuration Setup"));
    setPage(StartPageId, &d->startPage);
@@ -555,7 +557,7 @@ MaemoDeviceConfigWizard::~MaemoDeviceConfigWizard()
    delete d;
 }

-LinuxDeviceConfiguration::Ptr MaemoDeviceConfigWizard::deviceConfiguration()
+IDevice::Ptr MaemoDeviceConfigWizard::device()
 {
    bool doTest;
    QString freePortsSpec;
@@ -32,14 +32,15 @@
 #ifndef MAEMODEVICECONFIGWIZARD_H
 #define MAEMODEVICECONFIGWIZARD_H

-#include <remotelinux/linuxdeviceconfiguration.h>
+#include <projectexplorer/devicesupport/idevice.h>
+#include <projectexplorer/devicesupport/idevicewizard.h>

 namespace Madde {
 namespace Internal {

 struct MaemoDeviceConfigWizardPrivate;

-class MaemoDeviceConfigWizard : public RemoteLinux::ILinuxDeviceConfigurationWizard
+class MaemoDeviceConfigWizard : public ProjectExplorer::IDeviceWizard
 {
    Q_OBJECT

@@ -47,7 +48,7 @@ public:
    explicit MaemoDeviceConfigWizard(QWidget *parent = 0);
    ~MaemoDeviceConfigWizard();

-    RemoteLinux::LinuxDeviceConfiguration::Ptr deviceConfiguration();
+    ProjectExplorer::IDevice::Ptr device();

    virtual int nextId() const;

@@ -34,7 +34,7 @@
 #include "maemoqemusettingswidget.h"

 #include <coreplugin/icore.h>
-#include <remotelinux/remotelinux_constants.h>
+#include <projectexplorer/projectexplorerconstants.h>

 #include <QCoreApplication>
 #include <QDialog>
@@ -169,7 +169,7 @@ QString MaemoQemuSettingsPage::pageId()

 QString MaemoQemuSettingsPage::pageCategory()
 {
-    return QLatin1String(RemoteLinux::Constants::RemoteLinuxSettingsCategory);
+    return QLatin1String(ProjectExplorer::Constants::DEVICE_SETTINGS_CATEGORY);
 }

 } // namespace Internal
@@ -29,28 +29,29 @@
 ** Nokia at qt-info@nokia.com.
 **
 **************************************************************************/
-#include "linuxdevicefactoryselectiondialog.h"
-#include "ui_linuxdevicefactoryselectiondialog.h"
+#include "devicefactoryselectiondialog.h"
+#include "ui_devicefactoryselectiondialog.h"

-#include "linuxdeviceconfiguration.h"
+#include "idevice.h"
+#include "idevicefactory.h"

 #include <extensionsystem/pluginmanager.h>
 #include <utils/qtcassert.h>

 #include <QPushButton>

-namespace RemoteLinux {
+namespace ProjectExplorer {
 namespace Internal {

-LinuxDeviceFactorySelectionDialog::LinuxDeviceFactorySelectionDialog(QWidget *parent) :
-    QDialog(parent), ui(new Ui::LinuxDeviceFactorySelectionDialog)
+DeviceFactorySelectionDialog::DeviceFactorySelectionDialog(QWidget *parent) :
+    QDialog(parent), ui(new Ui::DeviceFactorySelectionDialog)
 {
    ui->setupUi(this);
    ui->buttonBox->button(QDialogButtonBox::Ok)->setText(tr("Start Wizard"));

-    const QList<ILinuxDeviceConfigurationFactory *> &factories
-        = ExtensionSystem::PluginManager::instance()->getObjects<ILinuxDeviceConfigurationFactory>();
-    foreach (const ILinuxDeviceConfigurationFactory * const factory, factories) {
+    const QList<IDeviceFactory *> &factories
+        = ExtensionSystem::PluginManager::instance()->getObjects<IDeviceFactory>();
+    foreach (const IDeviceFactory * const factory, factories) {
        m_factories << factory;
        ui->listWidget->addItem(factory->displayName());
    }
@@ -59,21 +60,21 @@ LinuxDeviceFactorySelectionDialog::LinuxDeviceFactorySelectionDialog(QWidget *pa
    handleItemSelectionChanged();
 }

-LinuxDeviceFactorySelectionDialog::~LinuxDeviceFactorySelectionDialog()
+DeviceFactorySelectionDialog::~DeviceFactorySelectionDialog()
 {
    delete ui;
 }

-void LinuxDeviceFactorySelectionDialog::handleItemSelectionChanged()
+void DeviceFactorySelectionDialog::handleItemSelectionChanged()
 {
    ui->buttonBox->button(QDialogButtonBox::Ok)
        ->setEnabled(!ui->listWidget->selectedItems().isEmpty());
 }

-const ILinuxDeviceConfigurationFactory *LinuxDeviceFactorySelectionDialog::selectedFactory() const
+const IDeviceFactory *DeviceFactorySelectionDialog::selectedFactory() const
 {
    return m_factories.at(ui->listWidget->row(ui->listWidget->selectedItems().first()));
 }

 } // namespace Internal
-} // namespace RemoteLinux
+} // namespace ProjectExplorer
@@ -30,35 +30,35 @@
 **
 **************************************************************************/

-#ifndef LINUXDEVICEFACTORYSELECTIONDIALOG_H
-#define LINUXDEVICEFACTORYSELECTIONDIALOG_H
+#ifndef DEVICEFACTORYSELECTIONDIALOG_H
+#define DEVICEFACTORYSELECTIONDIALOG_H

 #include <QList>
 #include <QDialog>

-namespace RemoteLinux {
-class ILinuxDeviceConfigurationFactory;
+namespace ProjectExplorer {
+class IDeviceFactory;

 namespace Internal {
-namespace Ui { class LinuxDeviceFactorySelectionDialog; }
+namespace Ui { class DeviceFactorySelectionDialog; }

-class LinuxDeviceFactorySelectionDialog : public QDialog
+class DeviceFactorySelectionDialog : public QDialog
 {
    Q_OBJECT

 public:
-    explicit LinuxDeviceFactorySelectionDialog(QWidget *parent = 0);
-    ~LinuxDeviceFactorySelectionDialog();
-    const ILinuxDeviceConfigurationFactory *selectedFactory() const;
+    explicit DeviceFactorySelectionDialog(QWidget *parent = 0);
+    ~DeviceFactorySelectionDialog();
+    const IDeviceFactory *selectedFactory() const;

 private:
    Q_SLOT void handleItemSelectionChanged();

-    Ui::LinuxDeviceFactorySelectionDialog *ui;
-    QList<const ILinuxDeviceConfigurationFactory *> m_factories;
+    Ui::DeviceFactorySelectionDialog *ui;
+    QList<const IDeviceFactory *> m_factories;
 };

 } // namespace Internal
-} // namespace RemoteLinux
+} // namespace ProjectExplorer

-#endif // LINUXDEVICEFACTORYSELECTIONDIALOG_H
+#endif // DEVICEFACTORYSELECTIONDIALOG_H
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>RemoteLinux::Internal::LinuxDeviceFactorySelectionDialog</class>
- <widget class="QDialog" name="RemoteLinux::Internal::LinuxDeviceFactorySelectionDialog">
+ <class>ProjectExplorer::Internal::DeviceFactorySelectionDialog</class>
+ <widget class="QDialog" name="ProjectExplorer::Internal::DeviceFactorySelectionDialog">
  <property name="geometry">
   <rect>
    <x>0</x>
@@ -54,7 +54,7 @@
  <connection>
   <sender>buttonBox</sender>
   <signal>accepted()</signal>
-   <receiver>RemoteLinux::Internal::LinuxDeviceFactorySelectionDialog</receiver>
+   <receiver>ProjectExplorer::Internal::DeviceFactorySelectionDialog</receiver>
   <slot>accept()</slot>
   <hints>
    <hint type="sourcelabel">
@@ -70,7 +70,7 @@
  <connection>
   <sender>buttonBox</sender>
   <signal>rejected()</signal>
-   <receiver>RemoteLinux::Internal::LinuxDeviceFactorySelectionDialog</receiver>
+   <receiver>ProjectExplorer::Internal::DeviceFactorySelectionDialog</receiver>
   <slot>reject()</slot>
   <hints>
    <hint type="sourcelabel">
@@ -0,0 +1,400 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** 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, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**************************************************************************/
+#include "devicemanager.h"
+
+#include "idevicefactory.h"
+
+#include <coreplugin/icore.h>
+#include <extensionsystem/pluginmanager.h>
+#include <utils/persistentsettings.h>
+#include <utils/qtcassert.h>
+
+#include <QFileInfo>
+#include <QHash>
+#include <QList>
+#include <QMainWindow>
+#include <QSettings>
+#include <QString>
+#include <QVariantHash>
+#include <QVariantList>
+
+#include <limits>
+
+namespace ProjectExplorer {
+namespace Internal {
+
+const char DeviceManagerKey[] = "DeviceManager";
+const char DeviceListKey[] = "DeviceList";
+const char DefaultDevicesKey[] = "DefaultDevices";
+
+class DeviceManagerPrivate
+{
+public:
+    static DeviceManager *instance;
+    static DeviceManager *clonedInstance;
+    QList<IDevice::Ptr> devices;
+    QHash<QString, IDevice::Id> defaultDevices;
+};
+DeviceManager *DeviceManagerPrivate::instance = 0;
+DeviceManager *DeviceManagerPrivate::clonedInstance = 0;
+
+} // namespace Internal
+
+using namespace Internal;
+
+
+DeviceManager *DeviceManager::instance()
+{
+    if (DeviceManagerPrivate::instance == 0) {
+        DeviceManagerPrivate::instance = new DeviceManager;
+        DeviceManagerPrivate::instance->load();
+    }
+    return DeviceManagerPrivate::instance;
+}
+
+void DeviceManager::deleteInstance()
+{
+    delete Internal::DeviceManagerPrivate::instance;
+    Internal::DeviceManagerPrivate::instance = 0;
+}
+
+int DeviceManager::deviceCount() const
+{
+    return d->devices.count();
+}
+
+void DeviceManager::replaceInstance()
+{
+    QTC_ASSERT(DeviceManagerPrivate::instance, return);
+
+    copy(DeviceManagerPrivate::clonedInstance,
+        DeviceManagerPrivate::instance, false);
+    DeviceManagerPrivate::instance->save();
+    emit DeviceManagerPrivate::instance->deviceListChanged();
+    emit DeviceManagerPrivate::instance->updated();
+}
+
+void DeviceManager::removeClonedInstance()
+{
+    delete DeviceManagerPrivate::clonedInstance;
+    DeviceManagerPrivate::clonedInstance = 0;
+}
+
+DeviceManager *DeviceManager::cloneInstance()
+{
+    QTC_ASSERT(!DeviceManagerPrivate::clonedInstance, return 0);
+
+    DeviceManagerPrivate::clonedInstance = new DeviceManager;
+    copy(instance(), DeviceManagerPrivate::clonedInstance, true);
+    return DeviceManagerPrivate::clonedInstance;
+}
+
+void DeviceManager::copy(const DeviceManager *source, DeviceManager *target, bool deep)
+{
+    if (deep) {
+        foreach (const IDevice::ConstPtr &device, source->d->devices)
+            target->d->devices << device->clone();
+    } else {
+        target->d->devices = source->d->devices;
+    }
+    target->d->defaultDevices = source->d->defaultDevices;
+}
+
+void DeviceManager::save()
+{
+    Utils::PersistentSettingsWriter writer;
+    writer.saveValue(QLatin1String(DeviceManagerKey), toMap());
+    writer.save(settingsFilePath(), QLatin1String("QtCreatorDevices"), Core::ICore::mainWindow());
+}
+
+void DeviceManager::load()
+{
+    Utils::PersistentSettingsReader reader;
+    if (reader.load(settingsFilePath()))
+        fromMap(reader.restoreValues().value(QLatin1String(DeviceManagerKey)).toMap());
+    else
+        loadPre2_6();
+    ensureOneDefaultDevicePerType();
+}
+
+// TODO: Remove in 2.8
+void DeviceManager::loadPre2_6()
+{
+    QSettings *settings = Core::ICore::settings();
+    settings->beginGroup(QLatin1String("MaemoDeviceConfigs"));
+    const QVariantHash defaultDevsHash = settings->value(QLatin1String("DefaultConfigs")).toHash();
+    for (QVariantHash::ConstIterator it = defaultDevsHash.constBegin();
+            it != defaultDevsHash.constEnd(); ++it) {
+        d->defaultDevices.insert(it.key(), it.value().toULongLong());
+    }
+    int count = settings->beginReadArray(QLatin1String("ConfigList"));
+    for (int i = 0; i < count; ++i) {
+        settings->setArrayIndex(i);
+        QVariantMap map;
+        foreach (const QString &key, settings->childKeys())
+            map.insert(key, settings->value(key));
+        const IDeviceFactory *factory = factoryForDeviceType(IDevice::typeFromMap(map));
+        if (!factory)
+            continue;
+        IDevice::Ptr device = factory->loadDevice(map);
+        QTC_ASSERT(device, continue);
+        if (device->internalId() == IDevice::invalidId())
+            device->setInternalId(unusedId());
+        d->devices << device;
+    }
+    settings->endArray();
+    settings->endGroup();
+}
+
+void DeviceManager::fromMap(const QVariantMap &map)
+{
+    const QVariantMap defaultDevsMap = map.value(QLatin1String(DefaultDevicesKey)).toMap();
+    for (QVariantMap::ConstIterator it = defaultDevsMap.constBegin();
+         it != defaultDevsMap.constEnd(); ++it) {
+        d->defaultDevices.insert(it.key(), it.value().toULongLong());
+    }
+    const QVariantList deviceList = map.value(QLatin1String(DeviceListKey)).toList();
+    foreach (const QVariant &v, deviceList) {
+        const QVariantMap map = v.toMap();
+        const IDeviceFactory * const factory = factoryForDeviceType(IDevice::typeFromMap(map));
+        if (!factory)
+            continue;
+        IDevice::Ptr device = factory->loadDevice(map);
+        QTC_ASSERT(device, continue);
+        if (device->internalId() == IDevice::invalidId())
+            device->setInternalId(unusedId());
+        d->devices << device;
+    }
+}
+
+QVariantMap DeviceManager::toMap() const
+{
+    QVariantMap map;
+    QVariantMap defaultDeviceMap;
+    typedef QHash<QString, IDevice::Id> TypeIdHash;
+    for (TypeIdHash::ConstIterator it = d->defaultDevices.constBegin();
+             it != d->defaultDevices.constEnd(); ++it) {
+        defaultDeviceMap.insert(it.key(), it.value());
+    }
+    map.insert(QLatin1String(DefaultDevicesKey), defaultDeviceMap);
+    QVariantList deviceList;
+    foreach (const IDevice::ConstPtr &device, d->devices) {
+        if (!device->isAutoDetected())
+            deviceList << device->toMap();
+    }
+    map.insert(QLatin1String(DeviceListKey), deviceList);
+    return map;
+}
+
+QString DeviceManager::settingsFilePath()
+{
+    ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
+    return QFileInfo(pm->settings()->fileName()).absolutePath() + QLatin1String("/devices.xml");
+}
+
+void DeviceManager::addDevice(const IDevice::Ptr &device)
+{
+    QTC_ASSERT(this != DeviceManagerPrivate::instance || (device->isAutoDetected()), return);
+
+    // Ensure uniqueness of name.
+    QString name = device->displayName();
+    if (hasDevice(name)) {
+        const QString nameTemplate = name + QLatin1String(" (%1)");
+        int suffix = 2;
+        do
+            name = nameTemplate.arg(QString::number(suffix++));
+        while (hasDevice(name));
+    }
+    device->setDisplayName(name);
+    device->setInternalId(unusedId());
+    if (!defaultDevice(device->type()))
+        d->defaultDevices.insert(device->type(), device->internalId());
+    d->devices << device;
+    if (this == d->instance && d->clonedInstance)
+        d->clonedInstance->addDevice(device->clone());
+    emit deviceAdded(device);
+    emit updated();
+}
+
+void DeviceManager::removeDevice(int idx)
+{
+    const IDevice::ConstPtr device = deviceAt(idx);
+    QTC_ASSERT(device, return);
+    QTC_ASSERT(this != DeviceManagerPrivate::instance || device->isAutoDetected(), return);
+
+    const bool wasDefault = d->defaultDevices.value(device->type()) == device->internalId();
+    const QString deviceType = device->type();
+    d->devices.removeAt(idx);
+    emit deviceRemoved(idx);
+
+    if (wasDefault) {
+        for (int i = 0; i < d->devices.count(); ++i) {
+            if (deviceAt(i)->type() == deviceType) {
+                d->defaultDevices.insert(deviceAt(i)->type(), deviceAt(i)->internalId());
+                emit defaultStatusChanged(i);
+                break;
+            }
+        }
+    }
+    if (this == d->instance && d->clonedInstance) {
+        d->clonedInstance->removeDevice(d->clonedInstance->
+            indexForInternalId(device->internalId()));
+    }
+
+    emit updated();
+}
+
+void DeviceManager::setDeviceDisplayName(int i, const QString &name)
+{
+    QTC_ASSERT(this != DeviceManagerPrivate::instance, return);
+    QTC_ASSERT(i >= 0 && i < deviceCount(), return);
+
+    d->devices.at(i)->setDisplayName(name);
+    emit displayNameChanged(i);
+}
+
+void DeviceManager::setDefaultDevice(int idx)
+{
+    QTC_ASSERT(this != DeviceManagerPrivate::instance, return);
+    QTC_ASSERT(idx >= 0 && idx < deviceCount(), return);
+
+    const IDevice::ConstPtr &device = d->devices.at(idx);
+    const IDevice::ConstPtr &oldDefaultDevice = defaultDevice(device->type());
+    if (device == oldDefaultDevice)
+        return;
+    d->defaultDevices.insert(device->type(), device->internalId());
+    emit defaultStatusChanged(idx);
+    for (int i = 0; i < d->devices.count(); ++i) {
+        if (d->devices.at(i) == oldDefaultDevice) {
+            emit defaultStatusChanged(i);
+            break;
+        }
+    }
+
+    emit updated();
+}
+
+const IDeviceFactory *DeviceManager::factoryForDeviceType(const QString &type)
+{
+    const QList<IDeviceFactory *> &factories
+        = ExtensionSystem::PluginManager::instance()->getObjects<IDeviceFactory>();
+    foreach (const IDeviceFactory * const factory, factories) {
+        if (factory->supportsDeviceType(type))
+            return factory;
+    }
+    return 0;
+}
+
+QString DeviceManager::displayNameForDeviceType(const QString &type)
+{
+    if (const IDeviceFactory * const factory = factoryForDeviceType(type))
+        return factory->displayNameForDeviceType(type);
+    return tr("Unknown OS");
+}
+
+DeviceManager::DeviceManager() : d(new DeviceManagerPrivate)
+{
+}
+
+DeviceManager::~DeviceManager()
+{
+    delete d;
+}
+
+IDevice::ConstPtr DeviceManager::deviceAt(int idx) const
+{
+    QTC_ASSERT(idx >= 0 && idx < deviceCount(), return IDevice::ConstPtr());
+    return d->devices.at(idx);
+}
+
+IDevice::Ptr DeviceManager::mutableDeviceAt(int idx) const
+{
+    QTC_ASSERT(idx >= 0 && idx < deviceCount(), return IDevice::Ptr());
+    return d->devices.at(idx);
+}
+
+bool DeviceManager::hasDevice(const QString &name) const
+{
+    foreach (const IDevice::Ptr &device, d->devices) {
+        if (device->displayName() == name)
+            return true;
+    }
+    return false;
+}
+
+IDevice::ConstPtr DeviceManager::find(IDevice::Id id) const
+{
+    const int index = indexForInternalId(id);
+    return index == -1 ? IDevice::ConstPtr() : deviceAt(index);
+}
+
+IDevice::ConstPtr DeviceManager::defaultDevice(const QString &deviceType) const
+{
+    const IDevice::Id id = d->defaultDevices.value(deviceType, IDevice::invalidId());
+    if (id == IDevice::invalidId())
+        return IDevice::ConstPtr();
+    return find(id);
+}
+
+int DeviceManager::indexForInternalId(IDevice::Id internalId) const
+{
+    for (int i = 0; i < d->devices.count(); ++i) {
+        if (deviceAt(i)->internalId() == internalId)
+            return i;
+    }
+    return -1;
+}
+
+IDevice::Id DeviceManager::internalId(const IDevice::ConstPtr &device) const
+{
+    return device ? device->internalId() : IDevice::invalidId();
+}
+
+void DeviceManager::ensureOneDefaultDevicePerType()
+{
+    foreach (const IDevice::Ptr &device, d->devices) {
+        if (!defaultDevice(device->type()))
+            d->defaultDevices.insert(device->type(), device->internalId());
+    }
+}
+
+IDevice::Id DeviceManager::unusedId() const
+{
+    for (IDevice::Id id = 0; id <= std::numeric_limits<IDevice::Id>::max(); ++id) {
+        if (id != IDevice::invalidId() && !find(id))
+            return id;
+    }
+    QTC_CHECK(false);
+    return IDevice::invalidId();
+}
+
+} // namespace ProjectExplorer
@@ -29,51 +29,47 @@
 ** Nokia at qt-info@nokia.com.
 **
 **************************************************************************/
-#ifndef LINUXDEVICECONFIGURATIONS_H
-#define LINUXDEVICECONFIGURATIONS_H
+#ifndef DEVICEMANAGER_H
+#define DEVICEMANAGER_H

-#include "linuxdeviceconfiguration.h"
-#include "remotelinux_export.h"
+#include "idevice.h"
+
+#include <projectexplorer/projectexplorer_export.h>

 #include <QObject>

-QT_FORWARD_DECLARE_CLASS(QString)
-
-namespace RemoteLinux {
+namespace ProjectExplorer {
+class IDeviceFactory;
 namespace Internal {
-class LinuxDeviceConfigurationsPrivate;
-class LinuxDeviceConfigurationsSettingsWidget;
+class DeviceManagerPrivate;
+class DeviceSettingsWidget;
 } // namespace Internal

-class REMOTELINUX_EXPORT LinuxDeviceConfigurations : public QObject
+class PROJECTEXPLORER_EXPORT DeviceManager : public QObject
 {
    Q_OBJECT
-    friend class Internal::LinuxDeviceConfigurationsSettingsWidget;
+    friend class Internal::DeviceSettingsWidget;
+    friend class ProjectExplorerPlugin;
 public:
-    ~LinuxDeviceConfigurations();
+    ~DeviceManager();

-    static LinuxDeviceConfigurations *instance(QObject *parent = 0);
+    static DeviceManager *instance();

    int deviceCount() const;
-    LinuxDeviceConfiguration::ConstPtr deviceAt(int index) const;
-    LinuxDeviceConfiguration::ConstPtr find(LinuxDeviceConfiguration::Id id) const;
-    LinuxDeviceConfiguration::ConstPtr defaultDeviceConfig(const QString &deviceType) const;
-    bool hasConfig(const QString &name) const;
-    int indexForInternalId(LinuxDeviceConfiguration::Id internalId) const;
-    LinuxDeviceConfiguration::Id internalId(LinuxDeviceConfiguration::ConstPtr devConf) const;
+    IDevice::ConstPtr deviceAt(int index) const;
+    IDevice::ConstPtr find(IDevice::Id id) const;
+    IDevice::ConstPtr defaultDevice(const QString &deviceType) const;
+    bool hasDevice(const QString &name) const;
+    IDevice::Id internalId(const IDevice::ConstPtr &device) const;

-    QString defaultSshKeyFilePath() const;
+    void addDevice(const IDevice::Ptr &device);
+    void removeDevice(int index);

-    void addConfiguration(const LinuxDeviceConfiguration::Ptr &devConfig);
-    void removeConfiguration(int index);
-    void setConfigurationName(int i, const QString &name);
-    void setDefaultDevice(int index);
-
-public slots:
-    void setDefaultSshKeyFilePath(const QString &path);
+    static const IDeviceFactory *factoryForDeviceType(const QString &type);
+    static QString displayNameForDeviceType(const QString &type);

 signals:
-    void deviceAdded(const QSharedPointer<const LinuxDeviceConfiguration> &device);
+    void deviceAdded(const QSharedPointer<const IDevice> &device);
    void deviceRemoved(int index);
    void displayNameChanged(int index);
    void defaultStatusChanged(int index);
@@ -81,28 +77,33 @@ signals:
    void updated(); // Emitted for all of the above.

 private:
-    LinuxDeviceConfigurations(QObject *parent);
-
-    LinuxDeviceConfiguration::Ptr mutableDeviceAt(int index) const;
+    DeviceManager();

    void load();
    void save();
    void loadPre2_6();
    void fromMap(const QVariantMap &map);
    QVariantMap toMap() const;
-    static QString settingsFilePath();
+    void ensureOneDefaultDevicePerType();
+    IDevice::Id unusedId() const;
+    int indexForInternalId(IDevice::Id internalId) const;

-    static LinuxDeviceConfigurations *cloneInstance();
+    // For SettingsWidget.
+    IDevice::Ptr mutableDeviceAt(int index) const;
+    void setDeviceDisplayName(int i, const QString &name);
+    void setDefaultDevice(int index);
+    static DeviceManager *cloneInstance();
    static void replaceInstance();
    static void removeClonedInstance();
-    static void copy(const LinuxDeviceConfigurations *source,
-        LinuxDeviceConfigurations *target, bool deep);
-    void ensureOneDefaultConfigurationPerDeviceType();
-    LinuxDeviceConfiguration::Id unusedId() const;

-    Internal::LinuxDeviceConfigurationsPrivate * const d;
+    static QString settingsFilePath();
+    static void copy(const DeviceManager *source, DeviceManager *target, bool deep);
+
+    static void deleteInstance(); // For ProjectExplorerPlugin.
+
+    Internal::DeviceManagerPrivate * const d;
 };

-} // namespace RemoteLinux
+} // namespace ProjectExplorer

-#endif // LINUXDEVICECONFIGURATIONS_H
+#endif // DEVICEMANAGER_H
@@ -31,29 +31,27 @@
 **************************************************************************/
 #include "devicemanagermodel.h"

-#include "linuxdeviceconfigurations.h"
-#include "remotelinuxutils.h"
+#include "devicemanager.h"

 #include <QString>

-namespace RemoteLinux {
+namespace ProjectExplorer {
 namespace Internal {
 class DeviceManagerModelPrivate
 {
 public:
-    const LinuxDeviceConfigurations *deviceManager;
-    QList<LinuxDeviceConfiguration::ConstPtr> devices;
+    const DeviceManager *deviceManager;
+    QList<IDevice::ConstPtr> devices;
 };
 } // namespace Internal

-DeviceManagerModel::DeviceManagerModel(const LinuxDeviceConfigurations *deviceManager,
-        QObject *parent) :
+DeviceManagerModel::DeviceManagerModel(const DeviceManager *deviceManager, QObject *parent) :
    QAbstractListModel(parent), d(new Internal::DeviceManagerModelPrivate)
 {
    d->deviceManager = deviceManager;
    handleDeviceListChanged();
-    connect(deviceManager, SIGNAL(deviceAdded(QSharedPointer<const LinuxDeviceConfiguration>)),
-        SLOT(handleDeviceAdded(QSharedPointer<const LinuxDeviceConfiguration>)));
+    connect(deviceManager, SIGNAL(deviceAdded(QSharedPointer<const IDevice>)),
+        SLOT(handleDeviceAdded(QSharedPointer<const IDevice>)));
    connect(deviceManager, SIGNAL(deviceRemoved(int)), SLOT(handleDeviceRemoved(int)));
    connect(deviceManager, SIGNAL(displayNameChanged(int)), SLOT(handleDataChanged(int)));
    connect(deviceManager, SIGNAL(defaultStatusChanged(int)), SLOT(handleDataChanged(int)));
@@ -65,7 +63,7 @@ DeviceManagerModel::~DeviceManagerModel()
    delete d;
 }

-void DeviceManagerModel::handleDeviceAdded(const LinuxDeviceConfiguration::ConstPtr &device)
+void DeviceManagerModel::handleDeviceAdded(const IDevice::ConstPtr &device)
 {
    beginInsertRows(QModelIndex(), rowCount(), rowCount());
    d->devices << device;
@@ -104,13 +102,13 @@ QVariant DeviceManagerModel::data(const QModelIndex &index, int role) const
 {
    if (!index.isValid() || index.row() >= rowCount() || role != Qt::DisplayRole)
        return QVariant();
-    const LinuxDeviceConfiguration::ConstPtr devConf = d->devices.at(index.row());
-    QString name = devConf->displayName();
-    if (d->deviceManager->defaultDeviceConfig(devConf->type()) == devConf) {
-        name += QLatin1Char(' ') + tr("(default for %1)")
-            .arg(RemoteLinuxUtils::displayType(devConf->type()));
+    const IDevice::ConstPtr device = d->devices.at(index.row());
+    QString name = device->displayName();
+    if (d->deviceManager->defaultDevice(device->type()) == device) {
+        name = tr("%1 (default for %2)").arg(name,
+            d->deviceManager->displayNameForDeviceType(device->type()));
    }
    return name;
 }

-} // namespace RemoteLinux
+} // namespace ProjectExplorer
@@ -32,26 +32,25 @@
 #ifndef DEVICEMANAGERMODEL_H
 #define DEVICEMANAGERMODEL_H

-#include "remotelinux_export.h"
+#include <projectexplorer/projectexplorer_export.h>

 #include <QAbstractListModel>
 #include <QSharedPointer>

-namespace RemoteLinux {
+namespace ProjectExplorer {
 namespace Internal { class DeviceManagerModelPrivate; }
-class LinuxDeviceConfiguration;
-class LinuxDeviceConfigurations;
+class IDevice;
+class DeviceManager;

-class REMOTELINUX_EXPORT DeviceManagerModel : public QAbstractListModel
+class PROJECTEXPLORER_EXPORT DeviceManagerModel : public QAbstractListModel
 {
    Q_OBJECT
 public:
-    explicit DeviceManagerModel(const LinuxDeviceConfigurations *deviceManager,
-        QObject *parent = 0);
+    explicit DeviceManagerModel(const DeviceManager *deviceManager, QObject *parent = 0);
    ~DeviceManagerModel();

 private slots:
-    void handleDeviceAdded(const QSharedPointer<const LinuxDeviceConfiguration> &device);
+    void handleDeviceAdded(const QSharedPointer<const IDevice> &device);
    void handleDeviceRemoved(int idx);
    void handleDataChanged(int idx);
    void handleDeviceListChanged();
@@ -63,6 +62,6 @@ private:
    Internal::DeviceManagerModelPrivate * const d;
 };

-} // namespace RemoteLinux
+} // namespace ProjectExplorer

 #endif // DEVICEMANAGERMODEL_H
@@ -28,83 +28,84 @@
 ** Nokia at qt-info@nokia.com.
 **
 **************************************************************************/
-#include "remotelinuxsettingspages.h"
+#include "devicesettingspage.h"

-#include "linuxdeviceconfigurationssettingswidget.h"
-#include "remotelinux_constants.h"
+#include "devicesettingswidget.h"
+
+#include <projectexplorer/projectexplorerconstants.h>

 #include <QCoreApplication>
 #include <QString>
 #include <QIcon>

-namespace RemoteLinux {
+namespace ProjectExplorer {
 namespace Internal {

-LinuxDeviceConfigurationsSettingsPage::LinuxDeviceConfigurationsSettingsPage(QObject *parent)
+DeviceSettingsPage::DeviceSettingsPage(QObject *parent)
    : Core::IOptionsPage(parent)
 {
 }

-LinuxDeviceConfigurationsSettingsPage::~LinuxDeviceConfigurationsSettingsPage()
+DeviceSettingsPage::~DeviceSettingsPage()
 {
 }

-QString LinuxDeviceConfigurationsSettingsPage::id() const
+QString DeviceSettingsPage::id() const
 {
    return pageId();
 }

-QString LinuxDeviceConfigurationsSettingsPage::displayName() const
+QString DeviceSettingsPage::displayName() const
 {
-    return tr("Device Configurations");
+    return tr("Devices");
 }

-QString LinuxDeviceConfigurationsSettingsPage::category() const
+QString DeviceSettingsPage::category() const
 {
    return pageCategory();
 }

-QString LinuxDeviceConfigurationsSettingsPage::displayCategory() const
+QString DeviceSettingsPage::displayCategory() const
 {
-    return QCoreApplication::translate("RemoteLinux", "Devices");
+    return QCoreApplication::translate("ProjectExplorer", "Devices");
 }

-QIcon LinuxDeviceConfigurationsSettingsPage::categoryIcon() const
+QIcon DeviceSettingsPage::categoryIcon() const
 {
    return QIcon(QLatin1String(":/projectexplorer/images/MaemoDevice.png"));
 }

-bool LinuxDeviceConfigurationsSettingsPage::matches(const QString &searchKeyWord) const
+bool DeviceSettingsPage::matches(const QString &searchKeyWord) const
 {
    return m_keywords.contains(searchKeyWord, Qt::CaseInsensitive);
 }

-QWidget *LinuxDeviceConfigurationsSettingsPage::createPage(QWidget *parent)
+QWidget *DeviceSettingsPage::createPage(QWidget *parent)
 {
-    m_widget = new LinuxDeviceConfigurationsSettingsWidget(parent);
+    m_widget = new DeviceSettingsWidget(parent);
    if (m_keywords.isEmpty())
        m_keywords = m_widget->searchKeywords();
    return m_widget;
 }

-void LinuxDeviceConfigurationsSettingsPage::apply()
+void DeviceSettingsPage::apply()
 {
    m_widget->saveSettings();
 }

-void LinuxDeviceConfigurationsSettingsPage::finish()
+void DeviceSettingsPage::finish()
 {
 }

-QString LinuxDeviceConfigurationsSettingsPage::pageId()
+QString DeviceSettingsPage::pageId()
 {
-    return QLatin1String(Constants::RemoteLinuxSettingsPageId);
+    return QLatin1String(Constants::DEVICE_SETTINGS_PAGE_ID);
 }

-QString LinuxDeviceConfigurationsSettingsPage::pageCategory()
+QString DeviceSettingsPage::pageCategory()
 {
-    return QLatin1String(Constants::RemoteLinuxSettingsCategory);
+    return QLatin1String(Constants::DEVICE_SETTINGS_CATEGORY);
 }

 } // namespace Internal
-} // namespace RemoteLinux
+} // namespace ProjectExplorer
@@ -28,21 +28,21 @@
 ** Nokia at qt-info@nokia.com.
 **
 **************************************************************************/
-#ifndef REMOTELINUXSETTINGSPAGES_H
-#define REMOTELINUXSETTINGSPAGES_H
+#ifndef DEVICESETTINGSPAGE_H
+#define DEVICESETTINGSPAGE_H

 #include <coreplugin/dialogs/ioptionspage.h>

-namespace RemoteLinux {
+namespace ProjectExplorer {
 namespace Internal {
-class LinuxDeviceConfigurationsSettingsWidget;
+class DeviceSettingsWidget;

-class LinuxDeviceConfigurationsSettingsPage : public Core::IOptionsPage
+class DeviceSettingsPage : public Core::IOptionsPage
 {
    Q_OBJECT
 public:
-    LinuxDeviceConfigurationsSettingsPage(QObject *parent = 0);
-    ~LinuxDeviceConfigurationsSettingsPage();
+    DeviceSettingsPage(QObject *parent = 0);
+    ~DeviceSettingsPage();

    virtual QString id() const;
    virtual QString displayName() const;
@@ -59,10 +59,10 @@ public:

 private:
    QString m_keywords;
-    LinuxDeviceConfigurationsSettingsWidget *m_widget;
+    DeviceSettingsWidget *m_widget;
 };

 } // namespace Internal
-} // namespace RemoteLinux
+} // namespace ProjectExplorer

-#endif // REMOTELINUXSETTINGSPAGES_H
+#endif // DEVICESETTINGSPAGE_H
@@ -28,20 +28,20 @@
 ** Nokia at qt-info@nokia.com.
 **
 **************************************************************************/
-#include "linuxdeviceconfigurationssettingswidget.h"
-
-#include "ui_linuxdeviceconfigurationssettingswidget.h"
+#include "devicesettingswidget.h"
+#include "ui_devicesettingswidget.h"

+#include "devicefactoryselectiondialog.h"
+#include "devicemanager.h"
 #include "devicemanagermodel.h"
-#include "linuxdeviceconfigurations.h"
-#include "linuxdevicefactoryselectiondialog.h"
-#include "remotelinuxutils.h"
-#include "sshkeycreationdialog.h"
+#include "idevice.h"
+#include "idevicefactory.h"
+#include "idevicewidget.h"
+#include "idevicewizard.h"

 #include <coreplugin/icore.h>
 #include <extensionsystem/pluginmanager.h>
 #include <utils/portlist.h>
-#include <utils/ssh/sshremoteprocessrunner.h>

 #include <QFileInfo>
 #include <QRegExp>
@@ -58,19 +58,15 @@
 using namespace Core;
 using namespace Utils;

-namespace RemoteLinux {
+namespace ProjectExplorer {
 namespace Internal {
-namespace {
-const QLatin1String LastDeviceConfigIndexKey("LastDisplayedMaemoDeviceConfig");
-} // anonymous namespace
-
+const char LastDeviceIndexKey[] = "LastDisplayedMaemoDeviceConfig";

 class NameValidator : public QValidator
 {
 public:
-    NameValidator(const LinuxDeviceConfigurations *devConfigs,
-            QWidget *parent = 0)
-        : QValidator(parent), m_devConfigs(devConfigs)
+    NameValidator(const DeviceManager *deviceManager, QWidget *parent = 0)
+        : QValidator(parent), m_deviceManager(deviceManager)
    {
    }

@@ -79,7 +75,7 @@ public:
    virtual State validate(QString &input, int & /* pos */) const
    {
        if (input.trimmed().isEmpty()
-                || (input != m_oldName && m_devConfigs->hasConfig(input)))
+                || (input != m_oldName && m_deviceManager->hasDevice(input)))
            return Intermediate;
        return Acceptable;
    }
@@ -93,15 +89,15 @@ public:

 private:
    QString m_oldName;
-    const LinuxDeviceConfigurations * const m_devConfigs;
+    const DeviceManager * const m_deviceManager;
 };


-LinuxDeviceConfigurationsSettingsWidget::LinuxDeviceConfigurationsSettingsWidget(QWidget *parent)
+DeviceSettingsWidget::DeviceSettingsWidget(QWidget *parent)
    : QWidget(parent),
-      m_ui(new Ui::LinuxDeviceConfigurationsSettingsWidget),
-      m_devConfigs(LinuxDeviceConfigurations::cloneInstance()),
-      m_nameValidator(new NameValidator(m_devConfigs, this)),
+      m_ui(new Ui::DeviceSettingsWidget),
+      m_deviceManager(DeviceManager::cloneInstance()),
+      m_nameValidator(new NameValidator(m_deviceManager, this)),
      m_saveSettingsRequested(false),
      m_additionalActionsMapper(new QSignalMapper(this)),
      m_configWidget(0)
@@ -111,18 +107,18 @@ LinuxDeviceConfigurationsSettingsWidget::LinuxDeviceConfigurationsSettingsWidget
        SLOT(handleAdditionalActionRequest(QString)));
 }

-LinuxDeviceConfigurationsSettingsWidget::~LinuxDeviceConfigurationsSettingsWidget()
+DeviceSettingsWidget::~DeviceSettingsWidget()
 {
    if (m_saveSettingsRequested) {
-        Core::ICore::settings()->setValue(LastDeviceConfigIndexKey,
+        Core::ICore::settings()->setValue(QLatin1String(LastDeviceIndexKey),
            currentIndex());
-        LinuxDeviceConfigurations::replaceInstance();
+        DeviceManager::replaceInstance();
    }
-    LinuxDeviceConfigurations::removeClonedInstance();
+    DeviceManager::removeClonedInstance();
    delete m_ui;
 }

-QString LinuxDeviceConfigurationsSettingsWidget::searchKeywords() const
+QString DeviceSettingsWidget::searchKeywords() const
 {
    QString rc;
    QTextStream(&rc) << m_ui->configurationLabel->text()
@@ -133,112 +129,106 @@ QString LinuxDeviceConfigurationsSettingsWidget::searchKeywords() const
    return rc;
 }

-void LinuxDeviceConfigurationsSettingsWidget::initGui()
+void DeviceSettingsWidget::initGui()
 {
    m_ui->setupUi(this);
-    DeviceManagerModel * const model = new DeviceManagerModel(m_devConfigs, this);
+    DeviceManagerModel * const model = new DeviceManagerModel(m_deviceManager, this);
    m_ui->configurationComboBox->setModel(model);
    m_ui->nameLineEdit->setValidator(m_nameValidator);

    int lastIndex = Core::ICore::settings()
-        ->value(LastDeviceConfigIndexKey, 0).toInt();
+        ->value(QLatin1String(LastDeviceIndexKey), 0).toInt();
    if (lastIndex == -1)
        lastIndex = 0;
    if (lastIndex < m_ui->configurationComboBox->count())
        m_ui->configurationComboBox->setCurrentIndex(lastIndex);
    connect(m_ui->configurationComboBox, SIGNAL(currentIndexChanged(int)),
-        SLOT(currentConfigChanged(int)));
-    currentConfigChanged(currentIndex());
+        SLOT(currentDeviceChanged(int)));
+    currentDeviceChanged(currentIndex());
    connect(m_ui->defaultDeviceButton, SIGNAL(clicked()),
        SLOT(setDefaultDevice()));
 }

-void LinuxDeviceConfigurationsSettingsWidget::addConfig()
+void DeviceSettingsWidget::addDevice()
 {
-    const QList<ILinuxDeviceConfigurationFactory *> &factories
-        = ExtensionSystem::PluginManager::instance()->getObjects<ILinuxDeviceConfigurationFactory>();
+    const QList<IDeviceFactory *> &factories
+        = ExtensionSystem::PluginManager::instance()->getObjects<IDeviceFactory>();

    if (factories.isEmpty()) // Can't happen, because this plugin provides the generic one.
        return;

-    LinuxDeviceFactorySelectionDialog d;
+    DeviceFactorySelectionDialog d;
    if (d.exec() != QDialog::Accepted)
        return;

-    const QScopedPointer<ILinuxDeviceConfigurationWizard> wizard(d.selectedFactory()->createWizard(this));
+    const QScopedPointer<IDeviceWizard> wizard(d.selectedFactory()->createWizard(this));
    if (wizard->exec() != QDialog::Accepted)
        return;

-    m_devConfigs->addConfiguration(wizard->deviceConfiguration());
+    m_deviceManager->addDevice(wizard->device());
    m_ui->removeConfigButton->setEnabled(true);
    m_ui->configurationComboBox->setCurrentIndex(m_ui->configurationComboBox->count()-1);
 }

-void LinuxDeviceConfigurationsSettingsWidget::deleteConfig()
+void DeviceSettingsWidget::removeDevice()
 {
-    m_devConfigs->removeConfiguration(currentIndex());
-    if (m_devConfigs->deviceCount() == 0)
-        currentConfigChanged(-1);
+    m_deviceManager->removeDevice(currentIndex());
+    if (m_deviceManager->deviceCount() == 0)
+        currentDeviceChanged(-1);
 }

-void LinuxDeviceConfigurationsSettingsWidget::displayCurrent()
+void DeviceSettingsWidget::displayCurrent()
 {
-    const LinuxDeviceConfiguration::ConstPtr &current = currentConfig();
+    const IDevice::ConstPtr &current = currentDevice();
    m_ui->defaultDeviceButton->setEnabled(
-        m_devConfigs->defaultDeviceConfig(current->type()) != current);
-    m_ui->osTypeValueLabel->setText(RemoteLinuxUtils::displayType(current->type()));
+        m_deviceManager->defaultDevice(current->type()) != current);
+    m_ui->osTypeValueLabel->setText(DeviceManager::displayNameForDeviceType(current->type()));

    m_nameValidator->setDisplayName(current->displayName());
    m_ui->removeConfigButton->setEnabled(!current->isAutoDetected());
    fillInValues();
 }

-void LinuxDeviceConfigurationsSettingsWidget::fillInValues()
+void DeviceSettingsWidget::fillInValues()
 {
-    const LinuxDeviceConfiguration::ConstPtr &current = currentConfig();
+    const IDevice::ConstPtr &current = currentDevice();
    m_ui->nameLineEdit->setText(current->displayName());
 }

-void LinuxDeviceConfigurationsSettingsWidget::saveSettings()
+void DeviceSettingsWidget::saveSettings()
 {
    // We must defer this step because of a stupid bug on MacOS. See QTCREATORBUG-1675.
    m_saveSettingsRequested = true;
 }

-int LinuxDeviceConfigurationsSettingsWidget::currentIndex() const
+int DeviceSettingsWidget::currentIndex() const
 {
    return m_ui->configurationComboBox->currentIndex();
 }

-LinuxDeviceConfiguration::ConstPtr LinuxDeviceConfigurationsSettingsWidget::currentConfig() const
+QSharedPointer<const IDevice> DeviceSettingsWidget::currentDevice() const
 {
    Q_ASSERT(currentIndex() != -1);
-    return m_devConfigs->deviceAt(currentIndex());
+    return m_deviceManager->deviceAt(currentIndex());
 }

-void LinuxDeviceConfigurationsSettingsWidget::configNameEditingFinished()
+void DeviceSettingsWidget::deviceNameEditingFinished()
 {
    if (m_ui->configurationComboBox->count() == 0)
        return;

    const QString &newName = m_ui->nameLineEdit->text();
-    m_devConfigs->setConfigurationName(currentIndex(), newName);
+    m_deviceManager->setDeviceDisplayName(currentIndex(), newName);
    m_nameValidator->setDisplayName(newName);
 }

-void LinuxDeviceConfigurationsSettingsWidget::setDefaultDevice()
+void DeviceSettingsWidget::setDefaultDevice()
 {
-    m_devConfigs->setDefaultDevice(currentIndex());
+    m_deviceManager->setDefaultDevice(currentIndex());
    m_ui->defaultDeviceButton->setEnabled(false);
 }

-void LinuxDeviceConfigurationsSettingsWidget::showGenerateSshKeyDialog()
-{
-    SshKeyCreationDialog dialog(this);
-    dialog.exec();
-}
-
-void LinuxDeviceConfigurationsSettingsWidget::currentConfigChanged(int index)
+void DeviceSettingsWidget::currentDeviceChanged(int index)
 {
    qDeleteAll(m_additionalActionButtons);
    delete m_configWidget;
@@ -248,13 +238,11 @@ void LinuxDeviceConfigurationsSettingsWidget::currentConfigChanged(int index)
    m_ui->osSpecificGroupBox->setEnabled(false);
    if (index == -1) {
        m_ui->removeConfigButton->setEnabled(false);
-        m_ui->generateKeyButton->setEnabled(false);
        clearDetails();
        m_ui->defaultDeviceButton->setEnabled(false);
    } else {
        m_ui->removeConfigButton->setEnabled(true);
-        m_ui->generateKeyButton->setEnabled(true);
-        const ILinuxDeviceConfigurationFactory * const factory = factoryForCurrentConfig();
+        const IDeviceFactory * const factory = factoryForCurrentDevice();
        if (factory) {
            const QStringList &actionIds = factory->supportedDeviceActionIds();
            foreach (const QString &actionId, actionIds) {
@@ -267,11 +255,9 @@ void LinuxDeviceConfigurationsSettingsWidget::currentConfigChanged(int index)
            }
            if (!m_ui->osSpecificGroupBox->layout())
                new QVBoxLayout(m_ui->osSpecificGroupBox);
-            m_configWidget = factory->createWidget(m_devConfigs->mutableDeviceAt(currentIndex()),
+            m_configWidget = factory->createWidget(m_deviceManager->mutableDeviceAt(currentIndex()),
                                                   m_ui->osSpecificGroupBox);
            if (m_configWidget) {
-                connect(m_configWidget, SIGNAL(defaultSshKeyFilePathChanged(QString)),
-                        m_devConfigs, SLOT(setDefaultSshKeyFilePath(QString)));
                m_ui->osSpecificGroupBox->layout()->addWidget(m_configWidget);
                m_ui->osSpecificGroupBox->setEnabled(factory->isUserEditable());
            }
@@ -282,33 +268,27 @@ void LinuxDeviceConfigurationsSettingsWidget::currentConfigChanged(int index)
    }
 }

-void LinuxDeviceConfigurationsSettingsWidget::clearDetails()
+void DeviceSettingsWidget::clearDetails()
 {
    m_ui->nameLineEdit->clear();
    m_ui->osTypeValueLabel->clear();
 }

-const ILinuxDeviceConfigurationFactory *LinuxDeviceConfigurationsSettingsWidget::factoryForCurrentConfig() const
+const IDeviceFactory *DeviceSettingsWidget::factoryForCurrentDevice() const
 {
-    Q_ASSERT(currentConfig());
-    const QList<ILinuxDeviceConfigurationFactory *> &factories
-        = ExtensionSystem::PluginManager::instance()->getObjects<ILinuxDeviceConfigurationFactory>();
-    foreach (const ILinuxDeviceConfigurationFactory * const factory, factories) {
-        if (factory->supportsDeviceType(currentConfig()->type()))
-            return factory;
-    }
-    return 0;
+    Q_ASSERT(currentDevice());
+    return DeviceManager::factoryForDeviceType(currentDevice()->type());
 }

-void LinuxDeviceConfigurationsSettingsWidget::handleAdditionalActionRequest(const QString &actionId)
+void DeviceSettingsWidget::handleAdditionalActionRequest(const QString &actionId)
 {
-    const ILinuxDeviceConfigurationFactory * const factory = factoryForCurrentConfig();
+    const IDeviceFactory * const factory = factoryForCurrentDevice();
    Q_ASSERT(factory);
-    QDialog * const action = factory->createDeviceAction(actionId, currentConfig(), this);
+    QDialog * const action = factory->createDeviceAction(actionId, currentDevice(), this);
    if (action)
        action->exec();
    delete action;
 }

 } // namespace Internal
-} // namespace RemoteLinux
+} // namespace ProjectExplorer
@@ -29,8 +29,8 @@
 **
 **************************************************************************/

-#ifndef LINUXDEVICECONFIGURATIONSSETTINGSWIDGET_H
-#define LINUXDEVICECONFIGURATIONSSETTINGSWIDGET_H
+#ifndef DEVICESETTINGSWIDGET_H
+#define DEVICESETTINGSWIDGET_H

 #include <QList>
 #include <QString>
@@ -38,61 +38,57 @@
 #include <QWidget>

 QT_BEGIN_NAMESPACE
-class QLineEdit;
 class QSignalMapper;
 QT_END_NAMESPACE

-namespace RemoteLinux {
-class ILinuxDeviceConfigurationFactory;
-class LinuxDeviceConfiguration;
-class LinuxDeviceConfigurations;
-class ILinuxDeviceConfigurationWidget;
+namespace ProjectExplorer {
+class IDevice;
+class DeviceManager;
+class IDeviceFactory;
+class IDeviceWidget;

 namespace Internal {
-namespace Ui { class LinuxDeviceConfigurationsSettingsWidget; }
+namespace Ui { class DeviceSettingsWidget; }
 class NameValidator;

-class LinuxDeviceConfigurationsSettingsWidget : public QWidget
+class DeviceSettingsWidget : public QWidget
 {
    Q_OBJECT
 public:
-    LinuxDeviceConfigurationsSettingsWidget(QWidget *parent);
-    ~LinuxDeviceConfigurationsSettingsWidget();
+    DeviceSettingsWidget(QWidget *parent);
+    ~DeviceSettingsWidget();

    void saveSettings();
    QString searchKeywords() const;

 private slots:
-    void currentConfigChanged(int index);
-    void addConfig();
-    void deleteConfig();
-    void configNameEditingFinished();
+    void currentDeviceChanged(int index);
+    void addDevice();
+    void removeDevice();
+    void deviceNameEditingFinished();
    void setDefaultDevice();
-
-    void showGenerateSshKeyDialog();
-
    void handleAdditionalActionRequest(const QString &actionId);

 private:
    void initGui();
    void displayCurrent();
-    QSharedPointer<const LinuxDeviceConfiguration> currentConfig() const;
+    QSharedPointer<const IDevice> currentDevice() const;
    int currentIndex() const;
    void clearDetails();
    QString parseTestOutput();
    void fillInValues();
-    const ILinuxDeviceConfigurationFactory *factoryForCurrentConfig() const;
+    const IDeviceFactory *factoryForCurrentDevice() const;

-    Ui::LinuxDeviceConfigurationsSettingsWidget *m_ui;
-    LinuxDeviceConfigurations * const m_devConfigs;
+    Ui::DeviceSettingsWidget *m_ui;
+    DeviceManager * const m_deviceManager;
    NameValidator * const m_nameValidator;
    bool m_saveSettingsRequested;
    QList<QPushButton *> m_additionalActionButtons;
    QSignalMapper * const m_additionalActionsMapper;
-    ILinuxDeviceConfigurationWidget *m_configWidget;
+    IDeviceWidget *m_configWidget;
 };

 } // namespace Internal
-} // namespace RemoteLinux
+} // namespace ProjectExplorer

-#endif // LINUXDEVICECONFIGURATIONSSETTINGSWIDGET_H
+#endif // DEVICESETTINGSWIDGET_H
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>RemoteLinux::Internal::LinuxDeviceConfigurationsSettingsWidget</class>
- <widget class="QWidget" name="RemoteLinux::Internal::LinuxDeviceConfigurationsSettingsWidget">
+ <class>ProjectExplorer::Internal::DeviceSettingsWidget</class>
+ <widget class="QWidget" name="ProjectExplorer::Internal::DeviceSettingsWidget">
  <property name="geometry">
   <rect>
    <x>0</x>
@@ -24,7 +24,7 @@
       <item row="0" column="0">
        <widget class="QLabel" name="configurationLabel">
         <property name="text">
-          <string>&amp;Configuration:</string>
+          <string>&amp;Device:</string>
         </property>
         <property name="buddy">
          <cstring>configurationComboBox</cstring>
@@ -155,22 +155,6 @@
       </property>
      </widget>
     </item>
-     <item>
-      <widget class="QPushButton" name="generateKeyButton">
-       <property name="enabled">
-        <bool>false</bool>
-       </property>
-       <property name="focusPolicy">
-        <enum>Qt::StrongFocus</enum>
-       </property>
-       <property name="toolTip">
-        <string>Click here if you do not have an SSH key yet.</string>
-       </property>
-       <property name="text">
-        <string>&amp;Generate SSH Key...</string>
-       </property>
-      </widget>
-     </item>
     <item>
      <widget class="Line" name="line">
       <property name="orientation">
@@ -200,12 +184,12 @@
  <connection>
   <sender>addConfigButton</sender>
   <signal>clicked()</signal>
-   <receiver>RemoteLinux::Internal::LinuxDeviceConfigurationsSettingsWidget</receiver>
-   <slot>addConfig()</slot>
+   <receiver>ProjectExplorer::Internal::DeviceSettingsWidget</receiver>
+   <slot>addDevice()</slot>
   <hints>
    <hint type="sourcelabel">
-     <x>697</x>
-     <y>33</y>
+     <x>818</x>
+     <y>35</y>
    </hint>
    <hint type="destinationlabel">
     <x>516</x>
@@ -216,8 +200,8 @@
  <connection>
   <sender>nameLineEdit</sender>
   <signal>editingFinished()</signal>
-   <receiver>RemoteLinux::Internal::LinuxDeviceConfigurationsSettingsWidget</receiver>
-   <slot>configNameEditingFinished()</slot>
+   <receiver>ProjectExplorer::Internal::DeviceSettingsWidget</receiver>
+   <slot>deviceNameEditingFinished()</slot>
   <hints>
    <hint type="sourcelabel">
     <x>204</x>
@@ -229,31 +213,15 @@
    </hint>
   </hints>
  </connection>
-  <connection>
-   <sender>generateKeyButton</sender>
-   <signal>clicked()</signal>
-   <receiver>RemoteLinux::Internal::LinuxDeviceConfigurationsSettingsWidget</receiver>
-   <slot>showGenerateSshKeyDialog()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>697</x>
-     <y>131</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>358</x>
-     <y>0</y>
-    </hint>
-   </hints>
-  </connection>
  <connection>
   <sender>removeConfigButton</sender>
   <signal>clicked()</signal>
-   <receiver>RemoteLinux::Internal::LinuxDeviceConfigurationsSettingsWidget</receiver>
-   <slot>deleteConfig()</slot>
+   <receiver>ProjectExplorer::Internal::DeviceSettingsWidget</receiver>
+   <slot>removeDevice()</slot>
   <hints>
    <hint type="sourcelabel">
-     <x>697</x>
-     <y>63</y>
+     <x>818</x>
+     <y>67</y>
    </hint>
    <hint type="destinationlabel">
     <x>351</x>
@@ -263,16 +231,16 @@
  </connection>
 </connections>
 <slots>
-  <slot>configNameEditingFinished()</slot>
+  <slot>deviceNameEditingFinished()</slot>
  <slot>deviceTypeChanged()</slot>
  <slot>hostNameEditingFinished()</slot>
  <slot>sshPortEditingFinished()</slot>
  <slot>timeoutEditingFinished()</slot>
  <slot>userNameEditingFinished()</slot>
  <slot>passwordEditingFinished()</slot>
-  <slot>addConfig()</slot>
+  <slot>addDevice()</slot>
  <slot>selectionChanged()</slot>
-  <slot>deleteConfig()</slot>
+  <slot>removeDevice()</slot>
  <slot>authenticationTypeChanged()</slot>
  <slot>keyFileEditingFinished()</slot>
  <slot>testConfig()</slot>
@@ -0,0 +1,195 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** 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, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**************************************************************************/
+#include "idevice.h"
+
+#include <QString>
+
+/*!
+ * \class ProjectExplorer::IDevice
+ * \brief This is the base class for all devices.
+ *
+ * The term "device" refers
+ * here to some host to which e.g. files can be deployed or on which an application can run.
+ * In the typical case, this would be some sort of embedded computer connected in some way to
+ * the PC on which QtCreator runs. This class itself does not specify a connection protocol; that
+ * kind of detail is to be added by subclasses.
+ * Devices are managed by a \c DeviceManager.
+ * \sa ProjectExplorer::DeviceManager
+ */
+
+/*!
+ * \fn QString ProjectExplorer::IDevice::type() const
+ * \brief Identifies the type of the device.
+ * Devices with the same type share certain abilities.
+ * This attribute is immutable.
+ * \sa ProjectExplorer::IDeviceFactory
+ */
+
+
+/*!
+ * \fn QString ProjectExplorer::IDevice::displayName() const
+ * \brief A free-text name for the device to be displayed in GUI elements.
+ */
+
+/*!
+ * \fn bool ProjectExplorer::IDevice::isAutoDetected() const
+ * \brief True iff the device has been added via some sort of auto-detection mechanism.
+ * Devices that are not auto-detected can only ever be created interactively from the
+ * settings page.
+ * This attribute is immutable.
+ * \sa DeviceSettingsWidget
+ */
+
+/*!
+ * \fn ProjectExplorer::IDevice::Id ProjectExplorer::IDevice::internalId() const
+ * \brief Identify the device internally.
+ */
+
+/*!
+ * \fn ProjectExplorer::IDevice::Id ProjectExplorer::IDevice::invalidId()
+ * \brief A value that no device can ever have as its internal id.
+ */
+
+/*!
+ * \fn ProjectExplorer::IDevice::Ptr ProjectExploer::IDevice::clone() const
+ * \brief Creates an identical copy of a device object.
+ */
+
+/*!
+ * \fn void fromMap(const QVariantMap &map)
+ * \brief Restores a device object from a serialized state as written by \c toMap().
+ * If subclasses override this to restore additional state, they must call the base class
+ * implementation.
+ */
+
+/*!
+ * \fn QVariantMap toMap() const
+ * \brief Serializes a device object, e.g. to save it to a file.
+ * If subclasses override this to save additional state, they must call the base class
+ * implementation.
+ */
+
+namespace ProjectExplorer {
+
+const char DisplayNameKey[] = "Name";
+const char TypeKey[] = "OsType";
+const char InternalIdKey[] = "InternalId";
+
+namespace Internal {
+class IDevicePrivate
+{
+public:
+    QString displayName;
+    QString type;
+    IDevice::Origin origin;
+    IDevice::Id internalId;
+};
+} // namespace Internal
+
+IDevice::IDevice() : d(new Internal::IDevicePrivate)
+{
+}
+
+IDevice::IDevice(const QString &type, Origin origin) : d(new Internal::IDevicePrivate)
+{
+    d->type = type;
+    d->origin = origin;
+}
+
+IDevice::IDevice(const IDevice &other) : d(new Internal::IDevicePrivate)
+{
+    *d = *other.d;
+}
+
+IDevice::~IDevice()
+{
+    delete d;
+}
+
+QString IDevice::displayName() const
+{
+    return d->displayName;
+}
+
+void IDevice::setDisplayName(const QString &name)
+{
+    d->displayName = name;
+}
+
+QString IDevice::type() const
+{
+    return d->type;
+}
+
+bool IDevice::isAutoDetected() const
+{
+    return d->origin == AutoDetected;
+}
+
+IDevice::Id IDevice::internalId() const
+{
+    return d->internalId;
+}
+
+void IDevice::setInternalId(IDevice::Id id)
+{
+    d->internalId = id;
+}
+
+IDevice::Id IDevice::invalidId()
+{
+    return 0;
+}
+
+QString IDevice::typeFromMap(const QVariantMap &map)
+{
+    return map.value(QLatin1String(TypeKey)).toString();
+}
+
+void IDevice::fromMap(const QVariantMap &map)
+{
+    d->type = typeFromMap(map);
+    d->origin = ManuallyAdded;
+    d->displayName = map.value(QLatin1String(DisplayNameKey)).toString();
+    d->internalId = map.value(QLatin1String(InternalIdKey), invalidId()).toULongLong();
+}
+
+QVariantMap IDevice::toMap() const
+{
+    QVariantMap map;
+    map.insert(QLatin1String(DisplayNameKey), d->displayName);
+    map.insert(QLatin1String(TypeKey), d->type);
+    map.insert(QLatin1String(InternalIdKey), d->internalId);
+    return map;
+}
+
+} // namespace ProjectExplorer
@@ -0,0 +1,88 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** 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, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**************************************************************************/
+#ifndef IDEVICE_H
+#define IDEVICE_H
+
+#include <projectexplorer/projectexplorer_export.h>
+
+#include <QSharedPointer>
+#include <QVariantMap>
+
+namespace ProjectExplorer {
+namespace Internal { class IDevicePrivate; }
+
+// See cpp file for documentation.
+class PROJECTEXPLORER_EXPORT IDevice
+{
+    friend class DeviceManager;
+public:
+    typedef QSharedPointer<IDevice> Ptr;
+    typedef QSharedPointer<const IDevice> ConstPtr;
+
+    typedef quint64 Id;
+
+    enum Origin { ManuallyAdded, AutoDetected };
+
+    virtual ~IDevice();
+
+    QString displayName() const;
+    void setDisplayName(const QString &name);
+
+    QString type() const;
+    bool isAutoDetected() const;
+    Id internalId() const;
+
+    virtual void fromMap(const QVariantMap &map);
+    virtual Ptr clone() const = 0;
+
+    static Id invalidId();
+
+    static QString typeFromMap(const QVariantMap &map);
+
+protected:
+    IDevice();
+    IDevice(const QString &type, Origin origin);
+    IDevice(const IDevice &other);
+
+    virtual QVariantMap toMap() const;
+
+private:
+    void setInternalId(Id id);
+
+    IDevice &operator=(const IDevice &);
+
+    Internal::IDevicePrivate *d;
+};
+
+} // namespace ProjectExplorer
+
+#endif // IDEVICE_H
@@ -0,0 +1,129 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** 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, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**************************************************************************/
+#ifndef IDEVICEFACTORY_H
+#define IDEVICEFACTORY_H
+
+#include "idevice.h"
+#include <projectexplorer/projectexplorer_export.h>
+
+#include <QObject>
+#include <QStringList>
+#include <QVariantMap>
+
+QT_BEGIN_NAMESPACE
+class QDialog;
+class QWidget;
+QT_END_NAMESPACE
+
+namespace ProjectExplorer {
+class IDeviceWidget;
+class IDeviceWizard;
+
+/*!
+  \class ProjectExplorer::IDeviceFactory
+
+  \brief Provides an interface for classes providing services related to certain type of device.
+
+  The factory objects have to be added to the global object pool via
+  \c ExtensionSystem::PluginManager::addObject().
+  \sa ExtensionSystem::PluginManager::addObject()
+*/
+class PROJECTEXPLORER_EXPORT IDeviceFactory : public QObject
+{
+    Q_OBJECT
+
+public:
+    /*!
+      A short, one-line description of what kind of device this factory supports.
+    */
+    virtual QString displayName() const = 0;
+
+    /*!
+      A wizard that can create the types of device this factory supports.
+    */
+    virtual IDeviceWizard *createWizard(QWidget *parent = 0) const = 0;
+
+    /*!
+      Loads a device from a serialized state. The device must be of a matching type.
+    */
+    virtual IDevice::Ptr loadDevice(const QVariantMap &map) const = 0;
+
+    /*!
+      A widget that can configure the device this factory supports.
+    */
+    virtual IDeviceWidget *createWidget(const IDevice::Ptr &device, QWidget *parent = 0) const = 0;
+
+    /*!
+      Returns true iff this factory supports the given device type.
+    */
+    virtual bool supportsDeviceType(const QString &type) const = 0;
+
+    /*!
+      Returns a human-readable string for the given device type, if this factory supports that type.
+    */
+    virtual QString displayNameForDeviceType(const QString &type) const = 0;
+
+    /*!
+      Returns a list of ids representing actions that can be run on devices
+      that this factory supports. These actions will be available in the "Devices"
+      options page.
+    */
+    virtual QStringList supportedDeviceActionIds() const = 0;
+
+    /*!
+      A human-readable string for the given id. Will be displayed on a button which, when clicked,
+      starts the respective action.
+    */
+    virtual QString displayNameForActionId(const QString &actionId) const = 0;
+
+    /*!
+      True iff the user should be allowed to edit the devices created by this
+      factory. Returns true by default. Override if your factory creates fixed configurations
+      for which later editing makes no sense.
+    */
+    virtual bool isUserEditable() const { return true; }
+
+    /*!
+      Produces a dialog implementing the respective action. The dialog is supposed to be
+      modal, so implementers must make sure to make it interruptible as to not needlessly
+      block the UI.
+    */
+    virtual QDialog *createDeviceAction(const QString &actionId, const IDevice::ConstPtr &device,
+        QWidget *parent = 0) const = 0;
+
+protected:
+    IDeviceFactory(QObject *parent) : QObject(parent) { }
+};
+
+} // namespace ProjectExplorer
+
+#endif // IDEVICEFACTORY_H
@@ -0,0 +1,68 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** 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, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**************************************************************************/
+#ifndef IDEVICEWIDGET_H
+#define IDEVICEWIDGET_H
+
+#include "idevice.h"
+#include <projectexplorer/projectexplorer_export.h>
+
+#include <QWidget>
+
+namespace ProjectExplorer {
+
+/*!
+ \class ProjectExplorer::IDeviceWidget
+
+ \brief Provides an interface for the widget configuring an IDevice.
+
+ A class implementing this interface will display a widget in the configuration
+ options page "Devices".
+ It is used to let the user configure a particular device.
+*/
+
+class PROJECTEXPLORER_EXPORT IDeviceWidget : public QWidget
+{
+    Q_OBJECT
+
+protected:
+    IDeviceWidget(const IDevice::Ptr &device, QWidget *parent = 0)
+        : QWidget(parent), m_device(device) {}
+
+    IDevice::Ptr device() const { return m_device; }
+
+private:
+    IDevice::Ptr m_device;
+};
+
+} // namespace ProjectExplorer
+
+#endif // IDEVICEWIDGET_H
@@ -0,0 +1,64 @@
+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+**
+** GNU Lesser General Public License Usage
+**
+** 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, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** Other Usage
+**
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**************************************************************************/
+#ifndef IDEVICEWIZARD_H
+#define IDEVICEWIZARD_H
+
+#include "idevice.h"
+#include <projectexplorer/projectexplorer_export.h>
+
+#include <QWizard>
+
+namespace ProjectExplorer {
+
+/*!
+  \class ProjectExplorer::IDeviceWizard
+
+  \brief Provides an interface for wizards creating an IDevice subclass.
+
+  A class implementing this interface is a wizard whose final result is
+  an \c IDevice object. The wizard will be started when the user chooses the
+  "Add..." action from the "Devices" options page.
+*/
+class PROJECTEXPLORER_EXPORT IDeviceWizard : public QWizard
+{
+    Q_OBJECT
+
+public:
+    virtual IDevice::Ptr device() = 0;
+
+protected:
+    IDeviceWizard(QWidget *parent) : QWizard(parent) { }
+};
+
+} // namespace ProjectExplorer
+
+#endif // IDEVICEWIZARD_H
@@ -79,6 +79,8 @@
 #include "buildconfiguration.h"
 #include "miniprojecttargetselector.h"
 #include "taskhub.h"
+#include "devicesupport/devicemanager.h"
+#include "devicesupport/devicesettingspage.h"
 #include "publishing/ipublishingwizardfactory.h"
 #include "publishing/publishingwizardselectiondialog.h"

@@ -285,6 +287,7 @@ ProjectExplorerPlugin::ProjectExplorerPlugin()

 ProjectExplorerPlugin::~ProjectExplorerPlugin()
 {
+    DeviceManager::deleteInstance();
    removeObject(d->m_welcomePage);
    delete d->m_welcomePage;
    removeObject(this);
@@ -420,8 +423,9 @@ bool ProjectExplorerPlugin::initialize(const QStringList &arguments, QString *er

    addAutoReleasedObject(new ProjectFileWizardExtension);

-    // Settings page
+    // Settings pages
    addAutoReleasedObject(new ProjectExplorerSettingsPage);
+    addAutoReleasedObject(new DeviceSettingsPage);

    // context menus
    Core::ActionContainer *msessionContextMenu =
@@ -3,6 +3,7 @@ TARGET = ProjectExplorer
 QT += xml \
    script \
    declarative
+
 include(../../qtcreatorplugin.pri)
 include(projectexplorer_dependencies.pri)
 include(../../libs/utils/utils.pri)
@@ -102,7 +103,16 @@ HEADERS += projectexplorer.h \
    appoutputpane.h \
    codestylesettingspropertiespage.h \
    settingsaccessor.h \
-    environmentitemswidget.h
+    environmentitemswidget.h \
+    devicesupport/idevice.h \
+    devicesupport/idevicewizard.h \
+    devicesupport/idevicewidget.h \
+    devicesupport/idevicefactory.h \
+    devicesupport/devicemanager.h \
+    devicesupport/devicemanagermodel.h \
+    devicesupport/devicefactoryselectiondialog.h \
+    devicesupport/devicesettingswidget.h \
+    devicesupport/devicesettingspage.h

 SOURCES += projectexplorer.cpp \
    abi.cpp \
@@ -188,7 +198,13 @@ SOURCES += projectexplorer.cpp \
    appoutputpane.cpp \
    codestylesettingspropertiespage.cpp \
    settingsaccessor.cpp \
-    environmentitemswidget.cpp
+    environmentitemswidget.cpp \
+    devicesupport/idevice.cpp \
+    devicesupport/devicemanager.cpp \
+    devicesupport/devicemanagermodel.cpp \
+    devicesupport/devicefactoryselectiondialog.cpp \
+    devicesupport/devicesettingswidget.cpp \
+    devicesupport/devicesettingspage.cpp

 FORMS += processstep.ui \
    toolchainoptionspage.ui \
@@ -200,7 +216,9 @@ FORMS += processstep.ui \
    targetsettingswidget.ui \
    doubletabwidget.ui \
    publishing/publishingwizardselectiondialog.ui \
-    codestylesettingspropertiespage.ui
+    codestylesettingspropertiespage.ui \
+    devicesupport/devicefactoryselectiondialog.ui \
+    devicesupport/devicesettingswidget.ui

 WINSOURCES += \
    windebuginterface.cpp \
@@ -271,7 +271,24 @@ QtcPlugin {
        "publishing/publishingwizardselectiondialog.ui",
        "publishing/ipublishingwizardfactory.h",
        "publishing/publishingwizardselectiondialog.cpp",
-        "publishing/publishingwizardselectiondialog.h"
+        "publishing/publishingwizardselectiondialog.h",
+        "devicesupport/idevice.h",
+        "devicesupport/idevice.cpp",
+        "devicesupport/devicemanager.h",
+        "devicesupport/devicemanager.cpp",
+        "devicesupport/devicemanagermodel.h",
+        "devicesupport/devicemanagermodel.cpp",
+        "devicesupport/devicesettingspage.h",
+        "devicesupport/devicesettingspage.cpp",
+        "devicesupport/devicefactoryselectiondialog.cpp",
+        "devicesupport/devicefactoryselectiondialog.h",
+        "devicesupport/devicefactoryselectiondialog.ui",
+        "devicesupport/devicesettingswidget.cpp",
+        "devicesupport/devicesettingswidget.h",
+        "devicesupport/devicesettingswidget.ui",
+        "devicesupport/idevicewizard.h",
+        "devicesupport/idevicewidget.h",
+        "devicesupport/idevicefactory.h"
    ]

    Group {
@@ -185,6 +185,10 @@ const char PROJECTEXPLORER_SETTINGS_CATEGORY_ICON[]  = ":/core/images/category_b
 const char PROJECTEXPLORER_SETTINGS_ID[] = "A.ProjectExplorer.ProjectExplorer";
 const char TOOLCHAIN_SETTINGS_PAGE_ID[] = "M.ProjectExplorer.ToolChainOptions";

+// Device settings page
+const char DEVICE_SETTINGS_CATEGORY[] = "X.Devices";
+const char DEVICE_SETTINGS_PAGE_ID[] = "AA.Device Settings";
+
 // Task categories
 const char TASK_CATEGORY_COMPILE[] = "Task.Category.Compile";
 const char TASK_CATEGORY_BUILDSYSTEM[] = "Task.Category.Buildsystem";
@@ -33,6 +33,7 @@

 #include "genericlinuxdeviceconfigurationwizard.h"
 #include "genericlinuxdeviceconfigurationwidget.h"
+#include "linuxdeviceconfiguration.h"
 #include "linuxdevicetestdialog.h"
 #include "publickeydeploymentdialog.h"
 #include "remotelinuxprocessesdialog.h"
@@ -41,10 +42,12 @@

 #include <utils/qtcassert.h>

+using namespace ProjectExplorer;
+
 namespace RemoteLinux {

 GenericLinuxDeviceConfigurationFactory::GenericLinuxDeviceConfigurationFactory(QObject *parent)
-    : ILinuxDeviceConfigurationFactory(parent)
+    : IDeviceFactory(parent)
 {
 }

@@ -53,16 +56,25 @@ QString GenericLinuxDeviceConfigurationFactory::displayName() const
    return tr("Generic Linux Device");
 }

-ILinuxDeviceConfigurationWizard *GenericLinuxDeviceConfigurationFactory::createWizard(QWidget *parent) const
+IDeviceWizard *GenericLinuxDeviceConfigurationFactory::createWizard(QWidget *parent) const
 {
    return new GenericLinuxDeviceConfigurationWizard(parent);
 }

-ILinuxDeviceConfigurationWidget *GenericLinuxDeviceConfigurationFactory::createWidget(
-        const LinuxDeviceConfiguration::Ptr &deviceConfig,
-        QWidget *parent) const
+IDeviceWidget *GenericLinuxDeviceConfigurationFactory::createWidget(const IDevice::Ptr &device,
+    QWidget *parent) const
 {
-    return new GenericLinuxDeviceConfigurationWidget(deviceConfig, parent);
+    return new GenericLinuxDeviceConfigurationWidget(device.staticCast<LinuxDeviceConfiguration>(),
+                                                     parent);
+}
+
+IDevice::Ptr GenericLinuxDeviceConfigurationFactory::loadDevice(const QVariantMap &map) const
+{
+    QTC_ASSERT(supportsDeviceType(IDevice::typeFromMap(map)),
+        return LinuxDeviceConfiguration::Ptr());
+    LinuxDeviceConfiguration::Ptr device = LinuxDeviceConfiguration::create();
+    device->fromMap(map);
+    return device;
 }

 bool GenericLinuxDeviceConfigurationFactory::supportsDeviceType(const QString &deviceType) const
@@ -70,7 +82,7 @@ bool GenericLinuxDeviceConfigurationFactory::supportsDeviceType(const QString &d
    return deviceType == QLatin1String(Constants::GenericLinuxOsType);
 }

-QString GenericLinuxDeviceConfigurationFactory::displayType(const QString &deviceType) const
+QString GenericLinuxDeviceConfigurationFactory::displayNameForDeviceType(const QString &deviceType) const
 {
    QTC_ASSERT(supportsDeviceType(deviceType), return QString());
    return tr("Generic Linux");
@@ -85,7 +97,7 @@ QStringList GenericLinuxDeviceConfigurationFactory::supportedDeviceActionIds() c

 QString GenericLinuxDeviceConfigurationFactory::displayNameForActionId(const QString &actionId) const
 {
-    Q_ASSERT(supportedDeviceActionIds().contains(actionId));
+    QTC_ASSERT(supportedDeviceActionIds().contains(actionId), return QString());

    if (actionId == QLatin1String(Constants::GenericTestDeviceActionId))
        return tr("Test");
@@ -97,18 +109,18 @@ QString GenericLinuxDeviceConfigurationFactory::displayNameForActionId(const QSt
 }

 QDialog *GenericLinuxDeviceConfigurationFactory::createDeviceAction(const QString &actionId,
-    const LinuxDeviceConfiguration::ConstPtr &deviceConfig, QWidget *parent) const
+    const IDevice::ConstPtr &device, QWidget *parent) const
 {
-    Q_ASSERT(supportedDeviceActionIds().contains(actionId));
+    QTC_ASSERT(supportedDeviceActionIds().contains(actionId), return 0);

+    const LinuxDeviceConfiguration::ConstPtr lDevice
+        = device.staticCast<const LinuxDeviceConfiguration>();
    if (actionId == QLatin1String(Constants::GenericTestDeviceActionId))
-        return new LinuxDeviceTestDialog(deviceConfig, new GenericLinuxDeviceTester, parent);
-    if (actionId == QLatin1String(Constants::GenericRemoteProcessesActionId)) {
-        return new RemoteLinuxProcessesDialog(new GenericRemoteLinuxProcessList(deviceConfig),
-            parent);
-    }
+        return new LinuxDeviceTestDialog(lDevice, new GenericLinuxDeviceTester, parent);
+    if (actionId == QLatin1String(Constants::GenericRemoteProcessesActionId))
+        return new RemoteLinuxProcessesDialog(new GenericRemoteLinuxProcessList(lDevice, parent));
    if (actionId == QLatin1String(Constants::GenericDeployKeyToDeviceActionId))
-        return PublicKeyDeploymentDialog::createDialog(deviceConfig, parent);
+        return PublicKeyDeploymentDialog::createDialog(lDevice, parent);
    return 0; // Can't happen.
 }

@@ -32,13 +32,14 @@
 #ifndef GENERICLINUXDEVICECONFIGURATIONFACTORY_H
 #define GENERICLINUXDEVICECONFIGURATIONFACTORY_H

-#include "linuxdeviceconfiguration.h"
 #include "remotelinux_export.h"

+#include <projectexplorer/devicesupport/idevicefactory.h>
+
 namespace RemoteLinux {

 class REMOTELINUX_EXPORT GenericLinuxDeviceConfigurationFactory
-    : public ILinuxDeviceConfigurationFactory
+    : public ProjectExplorer::IDeviceFactory
 {
    Q_OBJECT

@@ -46,16 +47,16 @@ public:
    GenericLinuxDeviceConfigurationFactory(QObject *parent = 0);

    QString displayName() const;
-    ILinuxDeviceConfigurationWizard *createWizard(QWidget *parent) const;
-    ILinuxDeviceConfigurationWidget *createWidget(
-            const LinuxDeviceConfiguration::Ptr &deviceConfig,
-            QWidget *parent = 0) const;
+    ProjectExplorer::IDeviceWizard *createWizard(QWidget *parent) const;
+    ProjectExplorer::IDeviceWidget *createWidget(const ProjectExplorer::IDevice::Ptr &device,
+        QWidget *parent = 0) const;
+    ProjectExplorer::IDevice::Ptr loadDevice(const QVariantMap &map) const;
    bool supportsDeviceType(const QString &deviceType) const;
-    QString displayType(const QString &deviceType) const;
+    QString displayNameForDeviceType(const QString &deviceType) const;
    QStringList supportedDeviceActionIds() const;
    QString displayNameForActionId(const QString &actionId) const;
    QDialog *createDeviceAction(const QString &actionId,
-        const LinuxDeviceConfiguration::ConstPtr &deviceConfig, QWidget *parent) const;
+        const ProjectExplorer::IDevice::ConstPtr &device, QWidget *parent) const;
 };

 } // namespace RemoteLinux
@@ -32,10 +32,9 @@
 #include "genericlinuxdeviceconfigurationwidget.h"
 #include "ui_genericlinuxdeviceconfigurationwidget.h"

-#include <remotelinux/linuxdeviceconfigurations.h>
-
 #include <utils/portlist.h>
 #include <utils/ssh/sshconnection.h>
+#include <utils/ssh/sshkeycreationdialog.h>

 #include <QTextStream>

@@ -45,7 +44,7 @@ using namespace Utils;
 GenericLinuxDeviceConfigurationWidget::GenericLinuxDeviceConfigurationWidget(
        const LinuxDeviceConfiguration::Ptr &deviceConfig,
        QWidget *parent) :
-    ILinuxDeviceConfigurationWidget(deviceConfig, parent),
+    ProjectExplorer::IDeviceWidget(deviceConfig, parent),
    m_ui(new Ui::GenericLinuxDeviceConfigurationWidget)
 {
    m_ui->setupUi(this);
@@ -62,7 +61,7 @@ GenericLinuxDeviceConfigurationWidget::GenericLinuxDeviceConfigurationWidget(
    connect(m_ui->sshPortSpinBox, SIGNAL(valueChanged(int)), this, SLOT(sshPortEditingFinished()));
    connect(m_ui->showPasswordCheckBox, SIGNAL(toggled(bool)), this, SLOT(showPassword(bool)));
    connect(m_ui->portsLineEdit, SIGNAL(editingFinished()), this, SLOT(handleFreePortsChanged()));
-    connect(m_ui->makeKeyFileDefaultButton, SIGNAL(clicked()), SLOT(setDefaultKeyFilePath()));
+    connect(m_ui->createKeyButton, SIGNAL(clicked()), SLOT(createNewKey()));

    initGui();
 }
@@ -84,7 +83,6 @@ void GenericLinuxDeviceConfigurationWidget::authenticationTypeChanged()
    m_ui->passwordLabel->setEnabled(usePassword);
    m_ui->keyFileLineEdit->setEnabled(!usePassword);
    m_ui->keyLabel->setEnabled(!usePassword);
-    m_ui->makeKeyFileDefaultButton->setEnabled(!usePassword);
 }

 void GenericLinuxDeviceConfigurationWidget::hostNameEditingFinished()
@@ -141,17 +139,19 @@ void GenericLinuxDeviceConfigurationWidget::showPassword(bool showClearText)
        ? QLineEdit::Normal : QLineEdit::Password);
 }

-void GenericLinuxDeviceConfigurationWidget::setDefaultKeyFilePath()
-{
-    emit defaultSshKeyFilePathChanged(m_ui->keyFileLineEdit->path());
-}
-
 void GenericLinuxDeviceConfigurationWidget::setPrivateKey(const QString &path)
 {
    m_ui->keyFileLineEdit->setPath(path);
    keyFileEditingFinished();
 }

+void GenericLinuxDeviceConfigurationWidget::createNewKey()
+{
+    SshKeyCreationDialog dialog(this);
+    if (dialog.exec() == QDialog::Accepted)
+        setPrivateKey(dialog.privateKeyFilePath());
+}
+
 void GenericLinuxDeviceConfigurationWidget::updatePortsWarningLabel()
 {
    m_ui->portsWarningLabel->setVisible(!deviceConfiguration()->freePorts().hasMore());
@@ -192,3 +192,8 @@ void GenericLinuxDeviceConfigurationWidget::initGui()
    m_ui->showPasswordCheckBox->setChecked(false);
    updatePortsWarningLabel();
 }
+
+LinuxDeviceConfiguration::Ptr GenericLinuxDeviceConfigurationWidget::deviceConfiguration() const
+{
+    return device().staticCast<LinuxDeviceConfiguration>();
+}
@@ -32,9 +32,10 @@
 #ifndef REMOTELINUX_GENERICLINUXDEVICECONFIGURATIONWIDGET_H
 #define REMOTELINUX_GENERICLINUXDEVICECONFIGURATIONWIDGET_H

-#include "remotelinux_export.h"
+#include <projectexplorer/devicesupport/idevicewidget.h>

 #include "linuxdeviceconfiguration.h"
+#include "remotelinux_export.h"

 namespace RemoteLinux {

@@ -42,14 +43,14 @@ namespace Ui {
 class GenericLinuxDeviceConfigurationWidget;
 }

-class REMOTELINUX_EXPORT GenericLinuxDeviceConfigurationWidget : public ILinuxDeviceConfigurationWidget
+class REMOTELINUX_EXPORT GenericLinuxDeviceConfigurationWidget
+        : public ProjectExplorer::IDeviceWidget
 {
    Q_OBJECT

 public:
    explicit GenericLinuxDeviceConfigurationWidget(
-            const LinuxDeviceConfiguration::Ptr &deviceConfig,
-            QWidget *parent = 0);
+        const LinuxDeviceConfiguration::Ptr &deviceConfig, QWidget *parent = 0);
    ~GenericLinuxDeviceConfigurationWidget();

 private slots:
@@ -62,12 +63,13 @@ private slots:
    void keyFileEditingFinished();
    void showPassword(bool showClearText);
    void handleFreePortsChanged();
-    void setDefaultKeyFilePath();
    void setPrivateKey(const QString &path);
+    void createNewKey();

 private:
    void updatePortsWarningLabel();
    void initGui();
+    LinuxDeviceConfiguration::Ptr deviceConfiguration() const;

    Ui::GenericLinuxDeviceConfigurationWidget *m_ui;
 };
@@ -7,7 +7,7 @@
    <x>0</x>
    <y>0</y>
    <width>393</width>
-    <height>185</height>
+    <height>206</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -215,9 +215,9 @@
      <widget class="Utils::PathChooser" name="keyFileLineEdit" native="true"/>
     </item>
     <item>
-      <widget class="QPushButton" name="makeKeyFileDefaultButton">
+      <widget class="QPushButton" name="createKeyButton">
       <property name="text">
-        <string>Set as Default</string>
+        <string>Create New...</string>
       </property>
      </widget>
     </item>
@@ -31,11 +31,13 @@
 #include "genericlinuxdeviceconfigurationwizard.h"

 #include "genericlinuxdeviceconfigurationwizardpages.h"
+#include "linuxdeviceconfiguration.h"
 #include "linuxdevicetestdialog.h"
 #include "linuxdevicetester.h"
 #include "remotelinux_constants.h"
 #include <utils/portlist.h>

+using namespace ProjectExplorer;
 using namespace Utils;

 namespace RemoteLinux {
@@ -58,7 +60,7 @@ public:
 } // namespace Internal

 GenericLinuxDeviceConfigurationWizard::GenericLinuxDeviceConfigurationWizard(QWidget *parent)
-    : ILinuxDeviceConfigurationWizard(parent),
+    : IDeviceWizard(parent),
      d(new Internal::GenericLinuxDeviceConfigurationWizardPrivate(this))
 {
    setWindowTitle(tr("New Generic Linux Device Configuration Setup"));
@@ -72,7 +74,7 @@ GenericLinuxDeviceConfigurationWizard::~GenericLinuxDeviceConfigurationWizard()
    delete d;
 }

-LinuxDeviceConfiguration::Ptr GenericLinuxDeviceConfigurationWizard::deviceConfiguration()
+IDevice::Ptr GenericLinuxDeviceConfigurationWizard::device()
 {
    Utils::SshConnectionParameters sshParams;
    sshParams.host = d->setupPage.hostName();
@@ -31,7 +31,9 @@
 #ifndef GENERICLINUXDEVICECONFIGURATIONWIZARD_H
 #define GENERICLINUXDEVICECONFIGURATIONWIZARD_H

-#include "linuxdeviceconfiguration.h"
+#include "remotelinux_export.h"
+
+#include <projectexplorer/devicesupport/idevicewizard.h>

 namespace RemoteLinux {
 namespace Internal {
@@ -39,7 +41,7 @@ class GenericLinuxDeviceConfigurationWizardPrivate;
 } // namespace Internal

 class REMOTELINUX_EXPORT GenericLinuxDeviceConfigurationWizard
-        : public ILinuxDeviceConfigurationWizard
+    : public ProjectExplorer::IDeviceWizard
 {
    Q_OBJECT

@@ -47,7 +49,7 @@ public:
    GenericLinuxDeviceConfigurationWizard(QWidget *parent = 0);
    ~GenericLinuxDeviceConfigurationWizard();

-    LinuxDeviceConfiguration::Ptr deviceConfiguration();
+    ProjectExplorer::IDevice::Ptr device();

 private:
    Internal::GenericLinuxDeviceConfigurationWizardPrivate * const d;
@@ -31,15 +31,14 @@
 **************************************************************************/
 #include "linuxdeviceconfiguration.h"

-#include "linuxdeviceconfigurations.h"
 #include "remotelinux_constants.h"

 #include <utils/portlist.h>
 #include <utils/ssh/sshconnection.h>
 #include <utils/qtcassert.h>

-#include <QSettings>
 #include <QDesktopServices>
+#include <QStringList>

 using namespace Utils;
 typedef SshConnectionParameters::AuthenticationType AuthType;
@@ -47,9 +46,6 @@ typedef SshConnectionParameters::AuthenticationType AuthType;
 namespace RemoteLinux {
 namespace Internal {
 namespace {
-const QLatin1String NameKey("Name");
-const QLatin1String OldOsVersionKey("OsVersion"); // Outdated, only use for upgrading.
-const QLatin1String TypeKey("OsType");
 const QLatin1String MachineTypeKey("Type");
 const QLatin1String HostKey("Host");
 const QLatin1String SshPortKey("SshPort");
@@ -59,8 +55,6 @@ const QLatin1String AuthKey("Authentication");
 const QLatin1String KeyFileKey("KeyFile");
 const QLatin1String PasswordKey("Password");
 const QLatin1String TimeoutKey("Timeout");
-const QLatin1String InternalIdKey("InternalId");
-const QLatin1String AttributesKey("Attributes");

 const AuthType DefaultAuthType(SshConnectionParameters::AuthenticationByKey);
 const int DefaultTimeout(10);
@@ -71,13 +65,8 @@ class LinuxDeviceConfigurationPrivate
 {
 public:
    SshConnectionParameters sshParameters;
-    QString displayName;
-    QString type;
    LinuxDeviceConfiguration::MachineType machineType;
    PortList freePorts;
-    LinuxDeviceConfiguration::Origin origin;
-    LinuxDeviceConfiguration::Id internalId;
-    QVariantHash attributes;
 };

 } // namespace Internal
@@ -89,14 +78,8 @@ LinuxDeviceConfiguration::~LinuxDeviceConfiguration()
    delete d;
 }

-// TODO: For pre-2.6 versions. Remove in 2.8.
-LinuxDeviceConfiguration::Ptr LinuxDeviceConfiguration::create(const QSettings &settings)
-{
-    return Ptr(new LinuxDeviceConfiguration(settings));
-}
-
 LinuxDeviceConfiguration::Ptr LinuxDeviceConfiguration::create(const QString &name,
-    const QString &type, MachineType machineType, Origin origin)
+   const QString &type, MachineType machineType, Origin origin)
 {
    return Ptr(new LinuxDeviceConfiguration(name, type, machineType, origin));
 }
@@ -107,58 +90,17 @@ LinuxDeviceConfiguration::LinuxDeviceConfiguration() : d(new LinuxDeviceConfigur

 LinuxDeviceConfiguration::LinuxDeviceConfiguration(const QString &name, const QString &type,
        MachineType machineType, Origin origin)
-    : d(new LinuxDeviceConfigurationPrivate)
+    : IDevice(type, origin), d(new LinuxDeviceConfigurationPrivate)
 {
-    d->displayName = name;
-    d->type = type;
+    setDisplayName(name);
    d->machineType = machineType;
-    d->origin = origin;
-}
-
-// TODO: For pre-2.6 versions. Remove in 2.8.
-LinuxDeviceConfiguration::LinuxDeviceConfiguration(const QSettings &settings)
-    : d(new LinuxDeviceConfigurationPrivate)
-{
-    d->origin = ManuallyAdded;
-    d->displayName = settings.value(NameKey).toString();
-    d->type = settings.value(TypeKey).toString();
-    d->machineType = static_cast<MachineType>(settings.value(MachineTypeKey, DefaultMachineType).toInt());
-    d->internalId = settings.value(InternalIdKey, InvalidId).toULongLong();
-    d->attributes = settings.value(AttributesKey).toHash();
-
-    // Convert from version < 2.3.
-    if (d->type.isEmpty()) {
-        const int oldOsType = settings.value(OldOsVersionKey, -1).toInt();
-        switch (oldOsType) {
-        case 0: d->type = QLatin1String("Maemo5OsType"); break;
-        case 1: d->type = QLatin1String("HarmattanOsType"); break;
-        case 2: d->type = QLatin1String("MeeGoOsType"); break;
-        default: d->type = QLatin1String(Constants::GenericLinuxOsType);
-        }
-    }
-
-    d->freePorts = PortList::fromString(settings.value(PortsSpecKey, QLatin1String("10000-10100")).toString());
-    d->sshParameters.host = settings.value(HostKey).toString();
-    d->sshParameters.port = settings.value(SshPortKey, 22).toInt();
-    d->sshParameters.userName = settings.value(UserNameKey).toString();
-    d->sshParameters.authenticationType
-        = static_cast<AuthType>(settings.value(AuthKey, DefaultAuthType).toInt());
-    d->sshParameters.password = settings.value(PasswordKey).toString();
-    d->sshParameters.privateKeyFile
-        = settings.value(KeyFileKey, defaultPrivateKeyFilePath()).toString();
-    d->sshParameters.timeout = settings.value(TimeoutKey, DefaultTimeout).toInt();
 }

 LinuxDeviceConfiguration::LinuxDeviceConfiguration(const LinuxDeviceConfiguration &other)
-    : d(new LinuxDeviceConfigurationPrivate)
+    : IDevice(other), d(new LinuxDeviceConfigurationPrivate)
 {
-    d->displayName = other.d->displayName;
-    d->type = other.d->type;
    d->machineType = other.machineType();
    d->freePorts = other.freePorts();
-    d->origin = other.d->origin;
-    d->internalId = other.d->internalId;
-    d->attributes = other.d->attributes;
    d->sshParameters = other.d->sshParameters;
 }

@@ -180,15 +122,8 @@ LinuxDeviceConfiguration::Ptr LinuxDeviceConfiguration::create()

 void LinuxDeviceConfiguration::fromMap(const QVariantMap &map)
 {
-    d->origin = ManuallyAdded;
-    d->displayName = map.value(NameKey).toString();
-    d->type = map.value(TypeKey).toString();
+    IDevice::fromMap(map);
    d->machineType = static_cast<MachineType>(map.value(MachineTypeKey, DefaultMachineType).toInt());
-    d->internalId = map.value(InternalIdKey, InvalidId).toULongLong();
-    const QVariantMap attrMap = map.value(AttributesKey).toMap();
-    for (QVariantMap::ConstIterator it = attrMap.constBegin(); it != attrMap.constEnd(); ++it)
-        d->attributes.insert(it.key(), it.value());
-
    d->freePorts = PortList::fromString(map.value(PortsSpecKey,
        QLatin1String("10000-10100")).toString());
    d->sshParameters.host = map.value(HostKey).toString();
@@ -203,9 +138,7 @@ void LinuxDeviceConfiguration::fromMap(const QVariantMap &map)

 QVariantMap LinuxDeviceConfiguration::toMap() const
 {
-    QVariantMap map;
-    map.insert(NameKey, d->displayName);
-    map.insert(TypeKey, d->type);
+    QVariantMap map = IDevice::toMap();
    map.insert(MachineTypeKey, d->machineType);
    map.insert(HostKey, d->sshParameters.host);
    map.insert(SshPortKey, d->sshParameters.port);
@@ -215,17 +148,10 @@ QVariantMap LinuxDeviceConfiguration::toMap() const
    map.insert(PasswordKey, d->sshParameters.password);
    map.insert(KeyFileKey, d->sshParameters.privateKeyFile);
    map.insert(TimeoutKey, d->sshParameters.timeout);
-    map.insert(InternalIdKey, d->internalId);
-    QVariantMap attrMap;
-    for (QVariantHash::ConstIterator it = d->attributes.constBegin();
-         it != d->attributes.constEnd(); ++it) {
-        attrMap.insert(it.key(), it.value());
-    }
-    map.insert(AttributesKey, attrMap);
    return map;
 }

-LinuxDeviceConfiguration::Ptr LinuxDeviceConfiguration::clone() const
+ProjectExplorer::IDevice::Ptr LinuxDeviceConfiguration::clone() const
 {
    return Ptr(new LinuxDeviceConfiguration(*this));
 }
@@ -241,11 +167,6 @@ LinuxDeviceConfiguration::MachineType LinuxDeviceConfiguration::machineType() co
    return d->machineType;
 }

-LinuxDeviceConfiguration::Id LinuxDeviceConfiguration::internalId() const
-{
-    return d->internalId;
-}
-
 void LinuxDeviceConfiguration::setSshParameters(const SshConnectionParameters &sshParameters)
 {
    d->sshParameters = sshParameters;
@@ -256,48 +177,6 @@ void LinuxDeviceConfiguration::setFreePorts(const PortList &freePorts)
    d->freePorts = freePorts;
 }

-void LinuxDeviceConfiguration::setAttribute(const QString &name, const QVariant &value)
-{
-    d->attributes[name] = value;
-}
-
-bool LinuxDeviceConfiguration::isAutoDetected() const
-{
-    return d->origin == AutoDetected;
-}
-
-QVariantHash LinuxDeviceConfiguration::attributes() const
-{
-    return d->attributes;
-}
-
-QVariant LinuxDeviceConfiguration::attribute(const QString &name) const
-{
-    return d->attributes.value(name);
-}
-
 PortList LinuxDeviceConfiguration::freePorts() const { return d->freePorts; }
-QString LinuxDeviceConfiguration::displayName() const { return d->displayName; }
-QString LinuxDeviceConfiguration::type() const { return d->type; }
-
-void LinuxDeviceConfiguration::setDisplayName(const QString &name) { d->displayName = name; }
-void LinuxDeviceConfiguration::setInternalId(Id id) { d->internalId = id; }
-
-const LinuxDeviceConfiguration::Id LinuxDeviceConfiguration::InvalidId = 0;
-
-
-ILinuxDeviceConfigurationWidget::ILinuxDeviceConfigurationWidget(
-        const LinuxDeviceConfiguration::Ptr &deviceConfig,
-        QWidget *parent)
-    : QWidget(parent),
-      m_deviceConfiguration(deviceConfig)
-{
-    QTC_CHECK(m_deviceConfiguration);
-}
-
-LinuxDeviceConfiguration::Ptr ILinuxDeviceConfigurationWidget::deviceConfiguration() const
-{
-    return m_deviceConfiguration;
-}

 } // namespace RemoteLinux
@@ -34,17 +34,7 @@

 #include "remotelinux_export.h"

-#include <QSharedPointer>
-#include <QString>
-#include <QStringList>
-#include <QVariantHash>
-#include <QVariantMap>
-#include <QWizard>
-
-QT_BEGIN_NAMESPACE
-class QDialog;
-class QSettings;
-QT_END_NAMESPACE
+#include <projectexplorer/devicesupport/idevice.h>

 namespace Utils {
 class SshConnectionParameters;
@@ -52,196 +42,49 @@ class PortList;
 }

 namespace RemoteLinux {
-class LinuxDeviceConfigurations;
-
 namespace Internal {
 class LinuxDeviceConfigurationPrivate;
 } // namespace Internal

-class REMOTELINUX_EXPORT LinuxDeviceConfiguration
+class REMOTELINUX_EXPORT LinuxDeviceConfiguration : public ProjectExplorer::IDevice
 {
-    friend class LinuxDeviceConfigurations;
 public:
    typedef QSharedPointer<LinuxDeviceConfiguration> Ptr;
    typedef QSharedPointer<const LinuxDeviceConfiguration> ConstPtr;

-    typedef quint64 Id;
-
    enum MachineType { Hardware, Emulator };
-    enum Origin { ManuallyAdded, AutoDetected };

    ~LinuxDeviceConfiguration();

    Utils::PortList freePorts() const;
    Utils::SshConnectionParameters sshParameters() const;
-    QString displayName() const;
-    QString type() const;
    MachineType machineType() const;
-    Id internalId() const;
-    bool isAutoDetected() const;
-    QVariantHash attributes() const;
-    QVariant attribute(const QString &name) const;

    void setSshParameters(const Utils::SshConnectionParameters &sshParameters);
    void setFreePorts(const Utils::PortList &freePorts);
-    void setAttribute(const QString &name, const QVariant &value);

    static QString defaultPrivateKeyFilePath();
    static QString defaultPublicKeyFilePath();

-    static const Id InvalidId;
-
    static Ptr create();
    static Ptr create(const QString &name, const QString &type, MachineType machineType,
        Origin origin = ManuallyAdded);
+
+    void fromMap(const QVariantMap &map);
+    ProjectExplorer::IDevice::Ptr clone() const;
 private:
    LinuxDeviceConfiguration();
    LinuxDeviceConfiguration(const QString &name, const QString &type, MachineType machineType,
        Origin origin);
-    LinuxDeviceConfiguration(const QSettings &settings);

    LinuxDeviceConfiguration(const LinuxDeviceConfiguration &other);
    LinuxDeviceConfiguration &operator=(const LinuxDeviceConfiguration &);

-    static Ptr create(const QSettings &settings);
-
-    void setDisplayName(const QString &name);
-    void setInternalId(Id id);
-    void setDefault(bool isDefault);
-
-    void fromMap(const QVariantMap &map);
    QVariantMap toMap() const;

-    Ptr clone() const;
-
    Internal::LinuxDeviceConfigurationPrivate *d;
 };

-
-/*!
-  \class RemoteLinux::ILinuxDeviceConfigurationWizard
-
-  \brief Provides an interface for wizards creating a LinuxDeviceConfiguration
-
-  A class implementing this interface is a wizard whose final result is
-  a LinuxDeviceConfiguration object. The wizard will be started when the user chooses the
-  "Add..." action from the "Linux devices" options page.
-*/
-class REMOTELINUX_EXPORT ILinuxDeviceConfigurationWizard : public QWizard
-{
-    Q_OBJECT
-
-public:
-    virtual LinuxDeviceConfiguration::Ptr deviceConfiguration() = 0;
-
-protected:
-    ILinuxDeviceConfigurationWizard(QWidget *parent) : QWizard(parent) {}
-};
-
-
-/*!
- \class RemoteLinux::LinuxDeviceConfigurationWidget : public QWidget
-
- \brief Provides an interface for the widget configuring a LinuxDeviceConfiguration
-
- A class implementing this interface will display a widget in the configuration
- options page "Linux Device", in the "Device configuration" tab.
- It's used to configure a particular device, the default widget is empty.
-*/
-class REMOTELINUX_EXPORT ILinuxDeviceConfigurationWidget : public QWidget
-{
-    Q_OBJECT
-
-public:
-    ILinuxDeviceConfigurationWidget(const LinuxDeviceConfiguration::Ptr &deviceConfig,
-                                    QWidget *parent = 0);
-
-signals:
-    void defaultSshKeyFilePathChanged(const QString &path);
-
-protected:
-    LinuxDeviceConfiguration::Ptr deviceConfiguration() const;
-
-private:
-    LinuxDeviceConfiguration::Ptr m_deviceConfiguration;
-};
-
-
-/*!
-  \class RemoteLinux::ILinuxDeviceConfiguration factory.
-
-  \brief Provides an interface for classes providing services related to certain type of Linux devices.
-
-  The main service is a wizard providing the device configuration itself.
-
-  The factory objects have to be added to the global object pool via
-  \c ExtensionSystem::PluginManager::addObject().
-  \sa ExtensionSystem::PluginManager::addObject()
-*/
-class REMOTELINUX_EXPORT ILinuxDeviceConfigurationFactory : public QObject
-{
-    Q_OBJECT
-
-public:
-    /*!
-      A short, one-line description of what kind of device this factory supports.
-    */
-    virtual QString displayName() const = 0;
-
-    /*!
-      A wizard that can create the types of device configuration this factory supports.
-    */
-    virtual ILinuxDeviceConfigurationWizard *createWizard(QWidget *parent = 0) const = 0;
-
-    /*!
-      A widget that can configure the device this factory supports.
-    */
-    virtual ILinuxDeviceConfigurationWidget *createWidget(
-            const LinuxDeviceConfiguration::Ptr &deviceConfig,
-            QWidget *parent = 0) const = 0;
-
-    /*!
-      Returns true iff this factory supports the given device type.
-    */
-    virtual bool supportsDeviceType(const QString &type) const = 0;
-
-    /*!
-      Returns a human-readable string for the given OS type, if this factory supports that type.
-    */
-    virtual QString displayType(const QString &type) const = 0;
-
-    /*!
-      Returns a list of ids representing actions that can be run on device configurations
-      that this factory supports. These actions will be available in the "Devices"
-      options page.
-    */
-    virtual QStringList supportedDeviceActionIds() const = 0;
-
-    /*!
-      A human-readable string for the given id. Will be displayed on a button which, when clicked,
-      will start the respective action.
-    */
-    virtual QString displayNameForActionId(const QString &actionId) const = 0;
-
-    /*!
-      True iff the user should be allowed to edit the device configurations created by this
-      factory. Returns true by default. Override if your factory creates fixed configurations
-      for which later editing makes no sense.
-    */
-    bool isUserEditable() const { return true; }
-
-    /*!
-      Produces a dialog implementing the respective action. The dialog is supposed to be
-      modal, so implementers must make sure to make it interruptible as to not needlessly
-      block the UI.
-    */
-    virtual QDialog *createDeviceAction(const QString &actionId,
-        const LinuxDeviceConfiguration::ConstPtr &deviceConfig, QWidget *parent = 0) const = 0;
-
-protected:
-    ILinuxDeviceConfigurationFactory(QObject *parent) : QObject(parent) {}
-};
-
 } // namespace RemoteLinux

 #endif // LINUXDEVICECONFIGURATION_H
@@ -1,418 +0,0 @@
-/**************************************************************************
-**
-** This file is part of Qt Creator
-**
-** Copyright (c) 2012 Nokia Corporation and/or its subsidiary(-ies).
-**
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-**
-** GNU Lesser General Public License Usage
-**
-** 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, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** Other Usage
-**
-** Alternatively, this file may be used in accordance with the terms and
-** conditions contained in a signed written agreement between you and Nokia.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**************************************************************************/
-#include "linuxdeviceconfigurations.h"
-
-#include "remotelinuxutils.h"
-
-#include <coreplugin/icore.h>
-#include <extensionsystem/pluginmanager.h>
-#include <utils/persistentsettings.h>
-#include <utils/qtcassert.h>
-
-#include <QFileInfo>
-#include <QHash>
-#include <QList>
-#include <QMainWindow>
-#include <QSettings>
-#include <QString>
-#include <QVariantHash>
-#include <QVariantList>
-
-#include <algorithm>
-#include <limits>
-
-namespace RemoteLinux {
-namespace Internal {
-
-const char FileFormatVersionKey[] = "DeviceManagerFileFormatVersion";
-const char DeviceManagerKey[] = "DeviceManager";
-const char DeviceListKey[] = "DeviceList";
-const char DefaultKeyFilePathKey[] = "DefaultKeyFile";
-const char DefaultDevicesKey[] = "DefaultDevices";
-
-namespace {
-
-class DevConfNameMatcher
-{
-public:
-    DevConfNameMatcher(const QString &name) : m_name(name) {}
-    bool operator()(const LinuxDeviceConfiguration::ConstPtr &devConfig)
-    {
-        return devConfig->displayName() == m_name;
-    }
-private:
-    const QString m_name;
-};
-
-} // anonymous namespace
-
-class LinuxDeviceConfigurationsPrivate
-{
-public:
-    static LinuxDeviceConfigurations *instance;
-    static LinuxDeviceConfigurations *clonedInstance;
-    QList<LinuxDeviceConfiguration::Ptr> devConfigs;
-    QHash<QString, LinuxDeviceConfiguration::Id> defaultConfigs;
-    QString defaultSshKeyFilePath;
-};
-LinuxDeviceConfigurations *LinuxDeviceConfigurationsPrivate::instance = 0;
-LinuxDeviceConfigurations *LinuxDeviceConfigurationsPrivate::clonedInstance = 0;
-
-} // namespace Internal
-
-using namespace Internal;
-
-
-LinuxDeviceConfigurations *LinuxDeviceConfigurations::instance(QObject *parent)
-{
-    if (LinuxDeviceConfigurationsPrivate::instance == 0) {
-        LinuxDeviceConfigurationsPrivate::instance = new LinuxDeviceConfigurations(parent);
-        LinuxDeviceConfigurationsPrivate::instance->load();
-    }
-    return LinuxDeviceConfigurationsPrivate::instance;
-}
-
-int LinuxDeviceConfigurations::deviceCount() const
-{
-    return d->devConfigs.count();
-}
-
-void LinuxDeviceConfigurations::replaceInstance()
-{
-    QTC_ASSERT(LinuxDeviceConfigurationsPrivate::instance, return);
-
-    copy(LinuxDeviceConfigurationsPrivate::clonedInstance,
-        LinuxDeviceConfigurationsPrivate::instance, false);
-    LinuxDeviceConfigurationsPrivate::instance->save();
-    emit LinuxDeviceConfigurationsPrivate::instance->deviceListChanged();
-    emit LinuxDeviceConfigurationsPrivate::instance->updated();
-}
-
-void LinuxDeviceConfigurations::removeClonedInstance()
-{
-    delete LinuxDeviceConfigurationsPrivate::clonedInstance;
-    LinuxDeviceConfigurationsPrivate::clonedInstance = 0;
-}
-
-LinuxDeviceConfigurations *LinuxDeviceConfigurations::cloneInstance()
-{
-    QTC_ASSERT(!LinuxDeviceConfigurationsPrivate::clonedInstance, return 0);
-
-    LinuxDeviceConfigurationsPrivate::clonedInstance
-        = new LinuxDeviceConfigurations(LinuxDeviceConfigurationsPrivate::instance);
-    copy(LinuxDeviceConfigurationsPrivate::instance,
-        LinuxDeviceConfigurationsPrivate::clonedInstance, true);
-    return LinuxDeviceConfigurationsPrivate::clonedInstance;
-}
-
-void LinuxDeviceConfigurations::copy(const LinuxDeviceConfigurations *source,
-    LinuxDeviceConfigurations *target, bool deep)
-{
-    if (deep) {
-        foreach (const LinuxDeviceConfiguration::ConstPtr &devConf, source->d->devConfigs)
-            target->d->devConfigs << devConf->clone();
-    } else {
-        target->d->devConfigs = source->d->devConfigs;
-    }
-    target->d->defaultSshKeyFilePath = source->d->defaultSshKeyFilePath;
-    target->d->defaultConfigs = source->d->defaultConfigs;
-}
-
-void LinuxDeviceConfigurations::save()
-{
-    Utils::PersistentSettingsWriter writer;
-    writer.saveValue(QLatin1String(FileFormatVersionKey), 1);
-    writer.saveValue(QLatin1String(DeviceManagerKey), toMap());
-    writer.save(settingsFilePath(), QLatin1String("QtCreatorDevices"), Core::ICore::mainWindow());
-}
-
-void LinuxDeviceConfigurations::load()
-{
-    Utils::PersistentSettingsReader reader;
-    if (reader.load(settingsFilePath())) {
-        const QVariantMap data = reader.restoreValues();
-        const int version = data.value(QLatin1String(FileFormatVersionKey), 0).toInt();
-        if (version < 1)
-            return;
-        fromMap(data.value(QLatin1String(DeviceManagerKey)).toMap());
-    } else {
-        loadPre2_6();
-    }
-    ensureOneDefaultConfigurationPerDeviceType();
-}
-
-void LinuxDeviceConfigurations::loadPre2_6()
-{
-    QSettings *settings = Core::ICore::settings();
-    settings->beginGroup(QLatin1String("MaemoDeviceConfigs"));
-    d->defaultSshKeyFilePath = settings->value(QLatin1String(DefaultKeyFilePathKey),
-        LinuxDeviceConfiguration::defaultPrivateKeyFilePath()).toString();
-    const QVariantHash defaultDevsHash = settings->value(QLatin1String("DefaultConfigs")).toHash();
-    for (QVariantHash::ConstIterator it = defaultDevsHash.constBegin();
-            it != defaultDevsHash.constEnd(); ++it) {
-        d->defaultConfigs.insert(it.key(), it.value().toULongLong());
-    }
-    int count = settings->beginReadArray(QLatin1String("ConfigList"));
-    for (int i = 0; i < count; ++i) {
-        settings->setArrayIndex(i);
-        LinuxDeviceConfiguration::Ptr devConf = LinuxDeviceConfiguration::create(*settings);
-        if (devConf->internalId() == LinuxDeviceConfiguration::InvalidId)
-            devConf->setInternalId(unusedId());
-        d->devConfigs << devConf;
-    }
-    settings->endArray();
-    settings->endGroup();
-}
-
-void LinuxDeviceConfigurations::fromMap(const QVariantMap &map)
-{
-    d->defaultSshKeyFilePath = map.value(QLatin1String(DefaultKeyFilePathKey),
-        LinuxDeviceConfiguration::defaultPrivateKeyFilePath()).toString();
-    const QVariantMap defaultDevsMap = map.value(QLatin1String(DefaultDevicesKey)).toMap();
-    for (QVariantMap::ConstIterator it = defaultDevsMap.constBegin();
-         it != defaultDevsMap.constEnd(); ++it) {
-        d->defaultConfigs.insert(it.key(), it.value().toULongLong());
-    }
-    const QVariantList deviceList = map.value(QLatin1String(DeviceListKey)).toList();
-    foreach (const QVariant &v, deviceList) {
-        LinuxDeviceConfiguration::Ptr device = LinuxDeviceConfiguration::create();
-        device->fromMap(v.toMap());
-        d->devConfigs << device;
-    }
-}
-
-QVariantMap LinuxDeviceConfigurations::toMap() const
-{
-    QVariantMap map;
-    map.insert(QLatin1String(DefaultKeyFilePathKey), d->defaultSshKeyFilePath);
-    QVariantMap defaultDeviceMap;
-    typedef QHash<QString, LinuxDeviceConfiguration::Id> TypeIdHash;
-    for (TypeIdHash::ConstIterator it = d->defaultConfigs.constBegin();
-             it != d->defaultConfigs.constEnd(); ++it) {
-        defaultDeviceMap.insert(it.key(), it.value());
-    }
-    map.insert(QLatin1String(DefaultDevicesKey), defaultDeviceMap);
-    QVariantList deviceList;
-    foreach (const LinuxDeviceConfiguration::ConstPtr &device, d->devConfigs) {
-        if (!device->isAutoDetected())
-            deviceList << device->toMap();
-    }
-    map.insert(QLatin1String(DeviceListKey), deviceList);
-    return map;
-}
-
-QString LinuxDeviceConfigurations::settingsFilePath()
-{
-    ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
-    return QFileInfo(pm->settings()->fileName()).absolutePath() + QLatin1String("/devices.xml");
-}
-
-void LinuxDeviceConfigurations::addConfiguration(const LinuxDeviceConfiguration::Ptr &devConfig)
-{
-    QTC_ASSERT(this != LinuxDeviceConfigurationsPrivate::instance
-        || (devConfig->isAutoDetected()), return);
-
-    // Ensure uniqueness of name.
-    QString name = devConfig->displayName();
-    if (hasConfig(name)) {
-        const QString nameTemplate = name + QLatin1String(" (%1)");
-        int suffix = 2;
-        do
-            name = nameTemplate.arg(QString::number(suffix++));
-        while (hasConfig(name));
-    }
-    devConfig->setDisplayName(name);
-    devConfig->setInternalId(unusedId());
-    if (!defaultDeviceConfig(devConfig->type()))
-        d->defaultConfigs.insert(devConfig->type(), devConfig->internalId());
-    d->devConfigs << devConfig;
-    if (this == d->instance && d->clonedInstance) {
-        d->clonedInstance->addConfiguration(
-            LinuxDeviceConfiguration::Ptr(new LinuxDeviceConfiguration(*devConfig)));
-    }
-    emit deviceAdded(devConfig);
-    emit updated();
-}
-
-void LinuxDeviceConfigurations::removeConfiguration(int idx)
-{
-    QTC_ASSERT(idx >= 0 && idx < deviceCount(), return);
-    const LinuxDeviceConfiguration::ConstPtr deviceConfig = deviceAt(idx);
-    QTC_ASSERT(this != LinuxDeviceConfigurationsPrivate::instance
-        || deviceConfig->isAutoDetected(), return);
-
-    const bool wasDefault
-        = d->defaultConfigs.value(deviceConfig->type()) == deviceConfig->internalId();
-    const QString deviceType = deviceConfig->type();
-    d->devConfigs.removeAt(idx);
-
-    emit deviceRemoved(idx);
-
-    if (wasDefault) {
-        for (int i = 0; i < d->devConfigs.count(); ++i) {
-            if (deviceAt(i)->type() == deviceType) {
-                d->defaultConfigs.insert(deviceAt(i)->type(), deviceAt(i)->internalId());
-                emit defaultStatusChanged(i);
-                break;
-            }
-        }
-    }
-    if (this == d->instance && d->clonedInstance) {
-        d->clonedInstance->removeConfiguration(d->clonedInstance->
-            indexForInternalId(deviceConfig->internalId()));
-    }
-
-    emit updated();
-}
-
-void LinuxDeviceConfigurations::setDefaultSshKeyFilePath(const QString &path)
-{
-    QTC_ASSERT(this != LinuxDeviceConfigurationsPrivate::instance, return);
-
-    d->defaultSshKeyFilePath = path;
-}
-
-QString LinuxDeviceConfigurations::defaultSshKeyFilePath() const
-{
-    return d->defaultSshKeyFilePath;
-}
-
-void LinuxDeviceConfigurations::setConfigurationName(int i, const QString &name)
-{
-    QTC_ASSERT(this != LinuxDeviceConfigurationsPrivate::instance, return);
-    QTC_ASSERT(i >= 0 && i < deviceCount(), return);
-
-    d->devConfigs.at(i)->setDisplayName(name);
-    emit displayNameChanged(i);
-}
-
-void LinuxDeviceConfigurations::setDefaultDevice(int idx)
-{
-    QTC_ASSERT(this != LinuxDeviceConfigurationsPrivate::instance, return);
-    QTC_ASSERT(idx >= 0 && idx < deviceCount(), return);
-
-    const LinuxDeviceConfiguration::ConstPtr &devConf = d->devConfigs.at(idx);
-    const LinuxDeviceConfiguration::ConstPtr &oldDefaultDevConf
-        = defaultDeviceConfig(devConf->type());
-    if (devConf == oldDefaultDevConf)
-        return;
-    d->defaultConfigs.insert(devConf->type(), devConf->internalId());
-    emit defaultStatusChanged(idx);
-    for (int i = 0; i < d->devConfigs.count(); ++i) {
-        if (d->devConfigs.at(i) == oldDefaultDevConf) {
-            emit defaultStatusChanged(i);
-            break;
-        }
-    }
-
-    emit updated();
-}
-
-LinuxDeviceConfigurations::LinuxDeviceConfigurations(QObject *parent)
-    : QObject(parent), d(new LinuxDeviceConfigurationsPrivate)
-{
-}
-
-LinuxDeviceConfiguration::Ptr LinuxDeviceConfigurations::mutableDeviceAt(int idx) const
-{
-    QTC_ASSERT(idx >= 0 && idx < deviceCount(), return LinuxDeviceConfiguration::Ptr());
-    return d->devConfigs.at(idx);
-}
-
-LinuxDeviceConfigurations::~LinuxDeviceConfigurations()
-{
-    delete d;
-}
-
-LinuxDeviceConfiguration::ConstPtr LinuxDeviceConfigurations::deviceAt(int idx) const
-{
-    QTC_ASSERT(idx >= 0 && idx < deviceCount(), return LinuxDeviceConfiguration::ConstPtr());
-    return d->devConfigs.at(idx);
-}
-
-bool LinuxDeviceConfigurations::hasConfig(const QString &name) const
-{
-    QList<LinuxDeviceConfiguration::Ptr>::ConstIterator resultIt =
-        std::find_if(d->devConfigs.constBegin(), d->devConfigs.constEnd(),
-            DevConfNameMatcher(name));
-    return resultIt != d->devConfigs.constEnd();
-}
-
-LinuxDeviceConfiguration::ConstPtr LinuxDeviceConfigurations::find(LinuxDeviceConfiguration::Id id) const
-{
-    const int index = indexForInternalId(id);
-    return index == -1 ? LinuxDeviceConfiguration::ConstPtr() : deviceAt(index);
-}
-
-LinuxDeviceConfiguration::ConstPtr LinuxDeviceConfigurations::defaultDeviceConfig(const QString &deviceType) const
-{
-    const LinuxDeviceConfiguration::Id id = d->defaultConfigs.value(deviceType,
-        LinuxDeviceConfiguration::InvalidId);
-    if (id == LinuxDeviceConfiguration::InvalidId)
-        return LinuxDeviceConfiguration::ConstPtr();
-    return find(id);
-}
-
-int LinuxDeviceConfigurations::indexForInternalId(LinuxDeviceConfiguration::Id internalId) const
-{
-    for (int i = 0; i < d->devConfigs.count(); ++i) {
-        if (deviceAt(i)->internalId() == internalId)
-            return i;
-    }
-    return -1;
-}
-
-LinuxDeviceConfiguration::Id LinuxDeviceConfigurations::internalId(LinuxDeviceConfiguration::ConstPtr devConf) const
-{
-    return devConf ? devConf->internalId() : LinuxDeviceConfiguration::InvalidId;
-}
-
-void LinuxDeviceConfigurations::ensureOneDefaultConfigurationPerDeviceType()
-{
-    foreach (const LinuxDeviceConfiguration::Ptr &devConf, d->devConfigs) {
-        if (!defaultDeviceConfig(devConf->type()))
-            d->defaultConfigs.insert(devConf->type(), devConf->internalId());
-    }
-}
-
-LinuxDeviceConfiguration::Id LinuxDeviceConfigurations::unusedId() const
-{
-    typedef LinuxDeviceConfiguration::Id IdType;
-    for (IdType id = 0; id <= std::numeric_limits<IdType>::max(); ++id) {
-        if (id != LinuxDeviceConfiguration::InvalidId && !find(id))
-            return id;
-    }
-    QTC_CHECK(false);
-    return LinuxDeviceConfiguration::InvalidId;
-}
-
-} // namespace RemoteLinux
@@ -13,9 +13,7 @@ HEADERS += \
    remotelinuxplugin.h \
    remotelinux_export.h \
    linuxdeviceconfiguration.h \
-    linuxdeviceconfigurations.h \
    remotelinuxrunconfiguration.h \
-    linuxdevicefactoryselectiondialog.h \
    publickeydeploymentdialog.h \
    genericlinuxdeviceconfigurationwizard.h \
    genericlinuxdeviceconfigurationfactory.h \
@@ -47,13 +45,10 @@ HEADERS += \
    linuxdevicetestdialog.h \
    remotelinuxprocesslist.h \
    remotelinuxprocessesdialog.h \
-    linuxdeviceconfigurationssettingswidget.h \
    remotelinuxenvironmentreader.h \
    sshkeydeployer.h \
    typespecificdeviceconfigurationlistmodel.h \
-    sshkeycreationdialog.h \
    remotelinuxusedportsgatherer.h \
-    remotelinuxsettingspages.h \
    remotelinuxutils.h \
    deploymentsettingsassistant.h \
    remotelinuxdeployconfigurationwidget.h \
@@ -62,8 +57,7 @@ HEADERS += \
    remotelinuxcustomcommanddeployservice.h \
    remotelinuxcustomcommanddeploymentstep.h \
    abstractembeddedlinuxtarget.h \
-    genericlinuxdeviceconfigurationwidget.h \
-    devicemanagermodel.h
+    genericlinuxdeviceconfigurationwidget.h

 SOURCES += \
    genericembeddedlinuxtarget.cpp \
@@ -72,9 +66,7 @@ SOURCES += \
    embeddedlinuxqtversionfactory.cpp \
    remotelinuxplugin.cpp \
    linuxdeviceconfiguration.cpp \
-    linuxdeviceconfigurations.cpp \
    remotelinuxrunconfiguration.cpp \
-    linuxdevicefactoryselectiondialog.cpp \
    publickeydeploymentdialog.cpp \
    genericlinuxdeviceconfigurationwizard.cpp \
    genericlinuxdeviceconfigurationfactory.cpp \
@@ -104,13 +96,10 @@ SOURCES += \
    linuxdevicetestdialog.cpp \
    remotelinuxprocesslist.cpp \
    remotelinuxprocessesdialog.cpp \
-    linuxdeviceconfigurationssettingswidget.cpp \
    remotelinuxenvironmentreader.cpp \
    sshkeydeployer.cpp \
    typespecificdeviceconfigurationlistmodel.cpp \
-    sshkeycreationdialog.cpp \
    remotelinuxusedportsgatherer.cpp \
-    remotelinuxsettingspages.cpp \
    remotelinuxutils.cpp \
    deploymentsettingsassistant.cpp \
    remotelinuxdeployconfigurationwidget.cpp \
@@ -119,16 +108,12 @@ SOURCES += \
    remotelinuxcustomcommanddeployservice.cpp \
    remotelinuxcustomcommanddeploymentstep.cpp \
    abstractembeddedlinuxtarget.cpp \
-    genericlinuxdeviceconfigurationwidget.cpp \
-    devicemanagermodel.cpp
+    genericlinuxdeviceconfigurationwidget.cpp

 FORMS += \
-    linuxdevicefactoryselectiondialog.ui \
    genericlinuxdeviceconfigurationwizardsetuppage.ui \
    linuxdevicetestdialog.ui \
    remotelinuxprocessesdialog.ui \
-    linuxdeviceconfigurationssettingswidget.ui \
-    sshkeycreationdialog.ui \
    remotelinuxdeployconfigurationwidget.ui \
    profilesupdatedialog.ui \
    genericlinuxdeviceconfigurationwidget.ui
@@ -60,11 +60,6 @@ QtcPlugin {
        "genericremotelinuxdeploystepfactory.h",
        "linuxdeviceconfiguration.cpp",
        "linuxdeviceconfiguration.h",
-        "linuxdeviceconfigurations.cpp",
-        "linuxdeviceconfigurations.h",
-        "linuxdevicefactoryselectiondialog.cpp",
-        "linuxdevicefactoryselectiondialog.h",
-        "linuxdevicefactoryselectiondialog.ui",
        "linuxdevicetestdialog.cpp",
        "linuxdevicetestdialog.h",
        "linuxdevicetester.cpp",
@@ -100,21 +95,14 @@ QtcPlugin {
        "remotelinuxrunconfigurationwidget.cpp",
        "remotelinuxrunconfigurationwidget.h",
        "remotelinuxruncontrol.h",
-        "remotelinuxsettingspages.cpp",
-        "remotelinuxsettingspages.h",
        "remotelinuxusedportsgatherer.cpp",
        "remotelinuxutils.cpp",
        "remotelinuxutils.h",
-        "sshkeycreationdialog.cpp",
-        "sshkeycreationdialog.h",
        "startgdbserverdialog.cpp",
        "startgdbserverdialog.h",
        "tarpackagecreationstep.h",
        "uploadandinstalltarpackagestep.h",
        "genericdirectuploadservice.h",
-        "linuxdeviceconfigurationssettingswidget.cpp",
-        "linuxdeviceconfigurationssettingswidget.h",
-        "linuxdeviceconfigurationssettingswidget.ui",
        "linuxdevicetestdialog.ui",
        "packageuploader.cpp",
        "packageuploader.h",
@@ -128,7 +116,6 @@ QtcPlugin {
        "remotelinuxprocessesdialog.h",
        "remotelinuxprocessesdialog.ui",
        "remotelinuxusedportsgatherer.h",
-        "sshkeycreationdialog.ui",
        "sshkeydeployer.cpp",
        "sshkeydeployer.h",
        "typespecificdeviceconfigurationlistmodel.cpp",
@@ -141,8 +128,6 @@ QtcPlugin {
        "remotelinuxruncontrolfactory.h",
        "tarpackagecreationstep.cpp",
        "uploadandinstalltarpackagestep.cpp",
-        "devicemanagermodel.h",
-        "devicemanagermodel.cpp",
        "images/embeddedtarget.png"
    ]

@@ -37,9 +37,6 @@ namespace Constants {

 const char GenericLinuxOsType[] = "GenericLinuxOsType";

-const char RemoteLinuxSettingsCategory[] = "X.RemoteLinux";
-const char RemoteLinuxSettingsPageId[] = "AA.Remote Linux Device Configurations";
-
 const char GenericTestDeviceActionId[] = "RemoteLinux.GenericTestDeviceAction";
 const char GenericDeployKeyToDeviceActionId[] = "RemoteLinux.GenericDeployKeyToDeviceAction";
 const char GenericRemoteProcessesActionId[] = "RemoteLinux.GenericRemoteProcessesAction";
@@ -33,10 +33,10 @@

 #include "abstractembeddedlinuxtarget.h"
 #include "deploymentinfo.h"
-#include "linuxdeviceconfigurations.h"
 #include "remotelinuxdeployconfigurationwidget.h"
 #include "typespecificdeviceconfigurationlistmodel.h"

+#include <projectexplorer/devicesupport/devicemanager.h>
 #include <qt4projectmanager/qt4target.h>

 using namespace ProjectExplorer;
@@ -88,7 +88,7 @@ void RemoteLinuxDeployConfiguration::initialize()

 void RemoteLinuxDeployConfiguration::handleDeviceConfigurationListUpdated()
 {
-    setDeviceConfig(LinuxDeviceConfigurations::instance()->internalId(d->deviceConfiguration));
+    setDeviceConfig(DeviceManager::instance()->internalId(d->deviceConfiguration));
 }

 void RemoteLinuxDeployConfiguration::setDeviceConfig(LinuxDeviceConfiguration::Id internalId)
@@ -102,8 +102,7 @@ bool RemoteLinuxDeployConfiguration::fromMap(const QVariantMap &map)
 {
    if (!DeployConfiguration::fromMap(map))
        return false;
-    setDeviceConfig(map.value(QLatin1String(DeviceIdKey),
-        LinuxDeviceConfiguration::InvalidId).toULongLong());
+    setDeviceConfig(map.value(QLatin1String(DeviceIdKey), IDevice::invalidId()).toULongLong());
    return true;
 }

@@ -111,7 +110,7 @@ QVariantMap RemoteLinuxDeployConfiguration::toMap() const
 {
    QVariantMap map = DeployConfiguration::toMap();
    map.insert(QLatin1String(DeviceIdKey),
-        LinuxDeviceConfigurations::instance()->internalId(d->deviceConfiguration));
+        DeviceManager::instance()->internalId(d->deviceConfiguration));
    return map;
 }

@@ -34,13 +34,13 @@
 #include "abstractembeddedlinuxtarget.h"
 #include "deployablefilesperprofile.h"
 #include "deploymentinfo.h"
-#include "linuxdeviceconfigurations.h"
 #include "remotelinuxdeployconfiguration.h"
-#include "remotelinuxsettingspages.h"
 #include "typespecificdeviceconfigurationlistmodel.h"

 #include <coreplugin/editormanager/editormanager.h>
 #include <coreplugin/icore.h>
+#include <projectexplorer/devicesupport/devicemanager.h>
+#include <projectexplorer/projectexplorerconstants.h>
 #include <utils/qtcassert.h>

 #include <QTreeView>
@@ -182,8 +182,7 @@ void RemoteLinuxDeployConfigurationWidget::handleDeviceConfigurationListChanged(
 {
    const LinuxDeviceConfiguration::ConstPtr &devConf
        = d->deployConfiguration->deviceConfiguration();
-    const LinuxDeviceConfiguration::Id internalId
-        = LinuxDeviceConfigurations::instance()->internalId(devConf);
+    const IDevice::Id internalId = DeviceManager::instance()->internalId(devConf);
    const int newIndex
        = d->deployConfiguration->target()->deviceConfigModel()->indexForInternalId(internalId);
    d->ui.deviceConfigsComboBox->setCurrentIndex(newIndex);
@@ -191,8 +190,9 @@ void RemoteLinuxDeployConfigurationWidget::handleDeviceConfigurationListChanged(

 void RemoteLinuxDeployConfigurationWidget::showDeviceConfigurations()
 {
-    Core::ICore::showOptionsDialog(LinuxDeviceConfigurationsSettingsPage::pageCategory(),
-                                               LinuxDeviceConfigurationsSettingsPage::pageId());
+    Core::ICore::showOptionsDialog(
+        QLatin1String(ProjectExplorer::Constants::DEVICE_SETTINGS_CATEGORY),
+        QLatin1String(ProjectExplorer::Constants::DEVICE_SETTINGS_PAGE_ID));
 }

 void RemoteLinuxDeployConfigurationWidget::openProjectFile()
@@ -37,12 +37,10 @@
 #include "deployablefile.h"
 #include "genericlinuxdeviceconfigurationfactory.h"
 #include "genericremotelinuxdeploystepfactory.h"
-#include "linuxdeviceconfigurations.h"
 #include "qt4projectmanager/qt4projectmanagerconstants.h"
 #include "remotelinuxdeployconfigurationfactory.h"
 #include "remotelinuxrunconfigurationfactory.h"
 #include "remotelinuxruncontrolfactory.h"
-#include "remotelinuxsettingspages.h"
 #include "startgdbserverdialog.h"

 #include <coreplugin/icore.h>
@@ -71,10 +69,7 @@ bool RemoteLinuxPlugin::initialize(const QStringList &arguments,
    Q_UNUSED(arguments)
    Q_UNUSED(errorMessage)

-    LinuxDeviceConfigurations::instance(this);
-
    addObject(this);
-    addAutoReleasedObject(new LinuxDeviceConfigurationsSettingsPage);
    addAutoReleasedObject(new GenericLinuxDeviceConfigurationFactory);
    addAutoReleasedObject(new RemoteLinuxRunConfigurationFactory);
    addAutoReleasedObject(new RemoteLinuxRunControlFactory);
@@ -34,12 +34,12 @@
 #include "linuxdeviceconfiguration.h"
 #include "remotelinuxrunconfiguration.h"
 #include "remotelinuxenvironmentreader.h"
-#include "remotelinuxsettingspages.h"
 #include "remotelinuxutils.h"

 #include <coreplugin/coreconstants.h>
 #include <coreplugin/icore.h>
 #include <projectexplorer/environmentwidget.h>
+#include <projectexplorer/projectexplorerconstants.h>
 #include <qt4projectmanager/qt4buildconfiguration.h>
 #include <qt4projectmanager/qt4target.h>
 #include <utils/detailswidget.h>
@@ -289,8 +289,9 @@ void RemoteLinuxRunConfigurationWidget::handleWorkingDirectoryChanged()
 void RemoteLinuxRunConfigurationWidget::showDeviceConfigurationsDialog(const QString &link)
 {
    if (link == QLatin1String("deviceconfig")) {
-        Core::ICore::showOptionsDialog(LinuxDeviceConfigurationsSettingsPage::pageCategory(),
-            LinuxDeviceConfigurationsSettingsPage::pageId());
+        Core::ICore::showOptionsDialog(
+            QLatin1String(ProjectExplorer::Constants::DEVICE_SETTINGS_CATEGORY),
+            QLatin1String(ProjectExplorer::Constants::DEVICE_SETTINGS_PAGE_ID));
    } else if (link == QLatin1String("debugger")) {
        Core::ICore::showOptionsDialog(QLatin1String("O.Debugger"),
            QLatin1String("M.Gdb"));
@@ -43,17 +43,6 @@ using namespace ExtensionSystem;

 namespace RemoteLinux {

-QString RemoteLinuxUtils::displayType(const QString &deviceType)
-{
-    const QList<ILinuxDeviceConfigurationFactory *> &factories
-        = PluginManager::instance()->getObjects<ILinuxDeviceConfigurationFactory>();
-    foreach (const ILinuxDeviceConfigurationFactory * const factory, factories) {
-        if (factory->supportsDeviceType(deviceType))
-            return factory->displayType(deviceType);
-    }
-    return QCoreApplication::translate("RemoteLinux", "Unknown OS");
-}
-
 QString RemoteLinuxUtils::deviceConfigurationName(const LinuxDeviceConfiguration::ConstPtr &devConf)
 {
    return devConf ? devConf->displayName() : QCoreApplication::translate("RemoteLinux", "(No device)");
@@ -42,7 +42,6 @@ class LinuxDeviceConfiguration;
 class REMOTELINUX_EXPORT RemoteLinuxUtils
 {
 public:
-    static QString displayType(const QString &deviceType);
    static QString deviceConfigurationName(const QSharedPointer<const LinuxDeviceConfiguration> &devConf);
 };

@@ -32,16 +32,14 @@

 #include "startgdbserverdialog.h"

-#include "devicemanagermodel.h"
 #include "remotelinuxprocesslist.h"
 #include "linuxdeviceconfiguration.h"
-#include "linuxdeviceconfigurations.h"
 #include "remotelinuxusedportsgatherer.h"

 #include <coreplugin/icore.h>
-
 #include <extensionsystem/pluginmanager.h>
-
+#include <projectexplorer/devicesupport/devicemanager.h>
+#include <projectexplorer/devicesupport/devicemanagermodel.h>
 #include <utils/pathchooser.h>
 #include <utils/portlist.h>
 #include <utils/qtcassert.h>
@@ -71,6 +69,7 @@
 #include <QVBoxLayout>

 using namespace Core;
+using namespace ProjectExplorer;
 using namespace Utils;

 const char LastSysroot[] = "RemoteLinux/LastSysroot";
@@ -88,8 +87,9 @@ public:

    LinuxDeviceConfiguration::ConstPtr currentDevice() const
    {
-        LinuxDeviceConfigurations *devices = LinuxDeviceConfigurations::instance();
-        return devices->deviceAt(deviceComboBox->currentIndex());
+        DeviceManager *devices = DeviceManager::instance();
+        return devices->deviceAt(deviceComboBox->currentIndex())
+            .dynamicCast<const LinuxDeviceConfiguration>();
    }

    StartGdbServerDialog *q;
@@ -174,7 +174,7 @@ StartGdbServerDialog::StartGdbServerDialog(QWidget *parent) :
 {
    setWindowTitle(tr("List of Remote Processes"));

-    LinuxDeviceConfigurations *devices = LinuxDeviceConfigurations::instance();
+    DeviceManager *devices = DeviceManager::instance();
    DeviceManagerModel * const model = new DeviceManagerModel(devices, this);

    QObject::connect(d->closeButton, SIGNAL(clicked()), this, SLOT(reject()));
@@ -218,9 +218,13 @@ StartGdbServerDialog::~StartGdbServerDialog()

 void StartGdbServerDialog::attachToDevice(int index)
 {
-    LinuxDeviceConfigurations *devices = LinuxDeviceConfigurations::instance();
+    DeviceManager *devices = DeviceManager::instance();
+    LinuxDeviceConfiguration::ConstPtr device
+        = devices->deviceAt(index).dynamicCast<const LinuxDeviceConfiguration>();
+    if (!device)
+        return;
    delete d->processList;
-    d->processList = new GenericRemoteLinuxProcessList(devices->deviceAt(index));
+    d->processList = new GenericRemoteLinuxProcessList(device);
    d->proxyModel.setSourceModel(d->processList);
    connect(d->processList, SIGNAL(error(QString)),
        SLOT(handleRemoteError(QString)));
@@ -261,6 +265,8 @@ void StartGdbServerDialog::attachToProcess()
    d->attachProcessButton->setEnabled(false);

    LinuxDeviceConfiguration::ConstPtr device = d->currentDevice();
+    if (!device)
+        return;
    PortList ports = device->freePorts();
    const int port = d->gatherer.getNextFreePort(&ports);
    const int row = d->proxyModel.mapToSource(indexes.first()).row();
@@ -31,17 +31,19 @@
 **************************************************************************/
 #include "typespecificdeviceconfigurationlistmodel.h"

-#include "linuxdeviceconfigurations.h"
 #include "remotelinux_constants.h"

+#include <projectexplorer/devicesupport/devicemanager.h>
+
+using namespace ProjectExplorer;
+
 namespace RemoteLinux {
 namespace Internal {

 TypeSpecificDeviceConfigurationListModel::TypeSpecificDeviceConfigurationListModel(const QString &deviceType,
    QObject *parent) : QAbstractListModel(parent), m_targetDeviceType(deviceType)
 {
-    const LinuxDeviceConfigurations * const devConfs
-        = LinuxDeviceConfigurations::instance();
+    const DeviceManager * const devConfs = DeviceManager::instance();
    connect(devConfs, SIGNAL(updated()), this, SIGNAL(updated()));
 }

@@ -54,8 +56,7 @@ int TypeSpecificDeviceConfigurationListModel::rowCount(const QModelIndex &parent
    if (parent.isValid())
        return 0;
    int count = 0;
-    const LinuxDeviceConfigurations * const devConfs
-        = LinuxDeviceConfigurations::instance();
+    const DeviceManager * const devConfs = DeviceManager::instance();
    const int devConfsCount = devConfs->deviceCount();
    if (m_targetDeviceType == QLatin1String(Constants::GenericLinuxOsType))
        return devConfsCount;
@@ -74,8 +75,8 @@ QVariant TypeSpecificDeviceConfigurationListModel::data(const QModelIndex &index
    const LinuxDeviceConfiguration::ConstPtr &devConf = deviceAt(index.row());
    Q_ASSERT(devConf);
    QString displayedName = devConf->displayName();
-    if (devConf->type() == m_targetDeviceType && LinuxDeviceConfigurations::instance()
-            ->defaultDeviceConfig(devConf->type()) == devConf) {
+    if (devConf->type() == m_targetDeviceType && DeviceManager::instance()
+            ->defaultDevice(devConf->type()) == devConf) {
        displayedName = tr("%1 (default)").arg(displayedName);
    }
    return displayedName;
@@ -84,15 +85,16 @@ QVariant TypeSpecificDeviceConfigurationListModel::data(const QModelIndex &index
 LinuxDeviceConfiguration::ConstPtr TypeSpecificDeviceConfigurationListModel::deviceAt(int idx) const
 {
    int currentRow = -1;
-    const LinuxDeviceConfigurations * const devConfs
-        = LinuxDeviceConfigurations::instance();
+    const DeviceManager * const devConfs = DeviceManager::instance();
    if (m_targetDeviceType == QLatin1String(Constants::GenericLinuxOsType))
-        return devConfs->deviceAt(idx);
+        return devConfs->deviceAt(idx).staticCast<const LinuxDeviceConfiguration>();
    const int devConfsCount = devConfs->deviceCount();
    for (int i = 0; i < devConfsCount; ++i) {
-        if (devConfs->deviceAt(i)->type() == m_targetDeviceType) {
+        const IDevice::ConstPtr device = devConfs->deviceAt(i);
+        if (device->type() == m_targetDeviceType
+                || m_targetDeviceType == QLatin1String(Constants::GenericLinuxOsType)) {
            if (++currentRow == idx)
-                return devConfs->deviceAt(i);
+                return devConfs->deviceAt(i).staticCast<const LinuxDeviceConfiguration>();
        }
    }
    Q_ASSERT(false);
@@ -101,16 +103,18 @@ LinuxDeviceConfiguration::ConstPtr TypeSpecificDeviceConfigurationListModel::dev

 LinuxDeviceConfiguration::ConstPtr TypeSpecificDeviceConfigurationListModel::defaultDeviceConfig() const
 {
-    return LinuxDeviceConfigurations::instance()->defaultDeviceConfig(m_targetDeviceType);
+    return DeviceManager::instance()->defaultDevice(m_targetDeviceType)
+        .staticCast<const LinuxDeviceConfiguration>();
 }

 LinuxDeviceConfiguration::ConstPtr TypeSpecificDeviceConfigurationListModel::find(LinuxDeviceConfiguration::Id id) const
 {
-    const LinuxDeviceConfiguration::ConstPtr &devConf
-        = LinuxDeviceConfigurations::instance()->find(id);
-    return devConf && (devConf->type() == m_targetDeviceType
-            || m_targetDeviceType == QLatin1String(Constants::GenericLinuxOsType))
-        ? devConf : defaultDeviceConfig();
+    const IDevice::ConstPtr &devConf = DeviceManager::instance()->find(id);
+    if (devConf && (devConf->type() == m_targetDeviceType
+            || m_targetDeviceType == QLatin1String(Constants::GenericLinuxOsType))) {
+        return devConf.staticCast<const LinuxDeviceConfiguration>();
+    }
+    return defaultDeviceConfig();
 }

 int TypeSpecificDeviceConfigurationListModel::indexForInternalId(LinuxDeviceConfiguration::Id id) const