Merge lp:~zeller-benjamin/qtcreator-plugin-ubuntu/devicepage into lp:qtcreator-plugin-ubuntu

[Benjamin Zeller]

- Added new QML based devices mode
- Reworked backend that handles devices and emulators and put
  it into QAbstractListModel derived classes to control them from QML
- Fixed a bug with starting applications on the device that don't use
   a launcher
- Switched to the RemoteLinux configuration widget , it provides better
  informations about the device state in the options dialog
- Easy creation of Kits for devices that are not assigned (Autocreate Kit)

New devices page

[lp:~zeller-benjamin/qtcreator-plugin-ubuntu/devicepage]

149. By Benjamin Zeller on 2014-04-25

Removed user file (how did they get in there?)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:149
http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-ci/229/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-trusty-amd64-ci/160
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-trusty-armhf-ci/160

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtcreator-plugin-ubuntu-ci/229/rebuild

review: Approve (continuous-integration)

[Zoltan Balogh (bzoltan)]

Is the welcome.qmlproject.user intentional?

[Benjamin Zeller (zeller-benjamin)]

> Is the welcome.qmlproject.user intentional?
Meh, of course not, also not the manifest and apparmor files

[lp:~zeller-benjamin/qtcreator-plugin-ubuntu/devicepage]

150. By Benjamin Zeller on 2014-04-26

Removed other not required files

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:150
http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-ci/230/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-trusty-amd64-ci/161
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-trusty-armhf-ci/161

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtcreator-plugin-ubuntu-ci/230/rebuild

review: Approve (continuous-integration)

[Zoltan Balogh (bzoltan)]

what about the share/qtcreator/ubuntu/devicespage/test.qml file ?

[lp:~zeller-benjamin/qtcreator-plugin-ubuntu/devicepage]

151. By Benjamin Zeller on 2014-04-27

deleted more files

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:151
http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-ci/231/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-trusty-amd64-ci/162
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtcreator-plugin-ubuntu-trusty-armhf-ci/162

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtcreator-plugin-ubuntu-ci/231/rebuild

review: Approve (continuous-integration)

[Zoltan Balogh (bzoltan)]

OK

review: Approve

=== added file '.excludes'
=== added file 'manifest.json'
--- manifest.json	1970-01-01 00:00:00 +0000
+++ manifest.json	2014-04-27 13:29:17 +0000
@@ -0,0 +1,15 @@
+{
+    "architecture": "all",
+    "description": "description of qtcreator-plugin-ubuntu",
+    "framework": "ubuntu-sdk-13.10",
+    "hooks": {
+        "qtcreator-plugin-ubuntu": {
+            "apparmor": "qtcreator-plugin-ubuntu.json",
+            "desktop": "qtcreator-plugin-ubuntu.desktop"
+        }
+    },
+    "maintainer": "Benjamin Zeller <[e-mail]>",
+    "name": "com.ubuntu.developer.zeller-benjamin.qtcreator-plugin-ubuntu",
+    "title": "qtcreator-plugin-ubuntu",
+    "version": "0.1"
+}
 \ No newline at end of file
 
=== added directory 'share/qtcreator/ubuntu/devicespage'
=== added file 'share/qtcreator/ubuntu/devicespage/.excludes'
=== added file 'share/qtcreator/ubuntu/devicespage/DeviceAdvancedTab.qml'
--- share/qtcreator/ubuntu/devicespage/DeviceAdvancedTab.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/DeviceAdvancedTab.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,92 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0 as Controls
+import QtQuick.Layouts 1.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+
+
+RowLayout {
+    Controls.ScrollView {
+        Layout.fillHeight: true
+        Layout.minimumWidth: units.gu(78)
+        UbuntuListView {
+            model: VisualItemModel{
+                Label {
+                    text: "Device Control"
+                    fontSize: "large"
+                    anchors.left: parent.left
+                }
+                ListItem.Standard {
+                    text:"Clone time config from Host to Device"
+                    control: Button{
+                        text: "Execute"
+                        enabled: !deviceItemView.deviceBusy
+                        onClicked: devicesModel.triggerCloneTimeConfig(deviceId)
+                    }
+                }
+                ListItem.Standard {
+                    text:"Enable port forwarding"
+                    control: Button{
+                        text: "Execute"
+                        enabled: !deviceItemView.deviceBusy
+                        onClicked: devicesModel.triggerPortForwarding(deviceId)
+                    }
+                }
+                ListItem.Standard {
+                    text:"Setup public key authentication"
+                    control: Button{
+                        text: "Execute"
+                        enabled: !deviceItemView.deviceBusy
+                        onClicked: devicesModel.triggerSSHSetup(deviceId)
+                    }
+                }
+                ListItem.Standard {
+                    text:"Open SSH connection to the device"
+                    control: Button{
+                        text: "Execute"
+                        enabled: !deviceItemView.deviceBusy
+                        onClicked: devicesModel.triggerSSHConnection(deviceId)
+                    }
+                }
+                ListItem.Divider{}
+                Label {
+                    text: "Device Mode"
+                    fontSize: "large"
+                }
+                ListItem.Standard {
+                    text:"Reboot"
+                    control: Button{
+                        text: "Execute"
+                        enabled: !deviceItemView.deviceBusy
+                        onClicked: devicesModel.triggerReboot(deviceId)
+                    }
+                }
+                ListItem.Standard {
+                    text:"Reboot to bootloader"
+                    control: Button{
+                        text: "Execute"
+                        enabled: !deviceItemView.deviceBusy
+                        onClicked: devicesModel.triggerRebootBootloader(deviceId)
+                    }
+                }
+                ListItem.Standard {
+                    text:"Reboot to recovery"
+                    control: Button{
+                        text: "Execute"
+                        enabled: !deviceItemView.deviceBusy
+                        onClicked: devicesModel.triggerRebootRecovery(deviceId)
+                    }
+                }
+                ListItem.Standard {
+                    text:"Shutdown"
+                    control: Button{
+                        text: "Execute"
+                        enabled: !deviceItemView.deviceBusy
+                        onClicked: devicesModel.triggerShutdown(deviceId)
+                    }
+                }
+            }
+        }
+    }
+}
+
 
=== added file 'share/qtcreator/ubuntu/devicespage/DeviceBuilderTab.qml'
--- share/qtcreator/ubuntu/devicespage/DeviceBuilderTab.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/DeviceBuilderTab.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,42 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0 as Controls
+import QtQuick.Layouts 1.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+
+RowLayout {
+    spacing: units.gu(1)
+    Controls.ScrollView {
+        Layout.fillHeight: true
+        Layout.minimumWidth: units.gu(78)
+
+        ColumnLayout {
+            Layout.fillWidth: true
+            Label {
+                text: "Platform development"
+                fontSize: "large"
+                anchors.left: parent.left
+                Layout.fillWidth: true
+            }
+            Label {
+                text: "The connected device can be turned  to be a native development environment.\n Use this feature with care and only if you know what are you doing."
+            }
+            FeatureStateItem {
+                text: "Has writeable image"
+                input: hasWriteableImage
+                inputRole: "hasWriteableImage"
+                height: 24
+                width: 300
+                checkable: !deviceItemView.deviceBusy
+            }
+            FeatureStateItem {
+                text: "Has device developer tools"
+                input: hasDeveloperTools
+                inputRole: "hasDeveloperTools"
+                height: 24
+                width: 300
+                checkable: !deviceItemView.deviceBusy
+            }
+        }
+    }
+}
 
=== added file 'share/qtcreator/ubuntu/devicespage/DeviceLogTab.qml'
--- share/qtcreator/ubuntu/devicespage/DeviceLogTab.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/DeviceLogTab.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,12 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0 as Controls
+import QtQuick.Layouts 1.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+
+
+Controls.TextArea {
+    readOnly: true
+    text: deviceLog
+    textFormat: TextEdit.AutoText
+}
 
=== added file 'share/qtcreator/ubuntu/devicespage/DevicePage.qml'
--- share/qtcreator/ubuntu/devicespage/DevicePage.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/DevicePage.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,105 @@
+import QtQuick 2.0
+import QtQuick.Layouts 1.0
+import QtQuick.Controls 1.0 as Controls
+
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+import Ubuntu.DevicesModel 0.1
+
+Page {
+    flickable: null
+
+    Controls.SplitView {
+        orientation: Qt.Horizontal
+        anchors.fill: parent
+        Controls.SplitView {
+            orientation: Qt.Vertical
+            width: 200
+            Layout.minimumWidth: 200
+            Layout.maximumWidth: 400
+
+            Controls.ScrollView {
+                Layout.fillHeight: true
+                UbuntuListView {
+                    id: devicesList
+                    objectName: "devicesList"
+                    model: devicesModel
+                    currentIndex: 0
+                    delegate: ListItem.Standard {
+                        id: delegate
+                        text: display
+                        selected: devicesList.currentIndex == index
+                        onClicked: devicesList.currentIndex = index
+                    }
+                    onCurrentIndexChanged: deviceMode.deviceSelected(currentIndex)
+                }
+            }
+            Controls.ToolBar {
+                Layout.fillWidth: true
+                Layout.minimumHeight: units.gu(5)
+                Layout.maximumHeight: units.gu(5)
+                Row{
+                    anchors.fill: parent
+                    spacing: units.gu(2)
+                    Controls.ToolButton {
+                        text: i18n.tr("Refresh devices")
+                        tooltip: text
+                        iconSource: "qrc:/ubuntu/images/view-refresh.png"
+                        onClicked: devicesModel.refresh()
+                    }
+                }
+            }
+        }
+        Item {
+            id: centerItem
+            Layout.minimumWidth: 400
+            Layout.fillWidth: true
+            property int currentIndex: devicesList.currentIndex
+            Repeater {
+                model: devicesModel
+                anchors.fill: parent
+                Rectangle{
+                    id: deviceItemView
+                    property bool deviceBusy: (detectionState != States.Done && detectionState != States.NotStarted)
+                    anchors.fill: parent
+                    anchors.margins: 12
+
+                    color: Qt.rgba(0.0, 0.0, 0.0, 0.01)
+                    visible: index == devicesList.currentIndex
+
+                    Controls.TabView {
+                        id: pagesTabView
+                        anchors.fill: parent
+                        visible: connectionState === States.DeviceReadyToUse || connectionState === States.DeviceConnected
+                        Controls.Tab {
+                            title: "Device"
+                            DeviceStatusTab{
+                            }
+                        }
+                        Controls.Tab {
+                            title: "Advanced"
+                            DeviceAdvancedTab{
+                            }
+                        }
+                        Controls.Tab {
+                            title: "Builder"
+                            DeviceBuilderTab{
+                            }
+                        }
+                        Controls.Tab {
+                            title: "Log"
+                            DeviceLogTab{}
+                        }
+                    }
+                    Label {
+                        visible: !pagesTabView.visible
+                        anchors.centerIn: parent
+                        text: "The device is currently not connected"
+                        fontSize: "large"
+                    }
+                }
+            }
+        }
+    }
+}
+
 
=== added file 'share/qtcreator/ubuntu/devicespage/DeviceStatusTab.qml'
--- share/qtcreator/ubuntu/devicespage/DeviceStatusTab.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/DeviceStatusTab.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,108 @@
+import QtQuick 2.0
+import QtQuick.Controls 1.0 as Controls
+import QtQuick.Layouts 1.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+import Ubuntu.DevicesModel 0.1
+
+RowLayout {
+    Controls.ScrollView {
+        id: scrollView
+        Layout.fillHeight: true
+        Layout.minimumWidth: units.gu(78)
+        ColumnLayout {
+            width: scrollView.width
+            Row {
+                Label {
+                    text:"Device Status: "+detectionStateString
+                    fontSize: "large"
+                }
+                Item {
+                    width: units.gu(2)
+                    height: parent.height
+                }
+                ActivityIndicator{
+                    visible: deviceItemView.deviceBusy
+                    running: true
+                }
+            }
+            ListItem.SingleValue {
+                text:i18n.tr("Serial ID")
+                Layout.fillWidth: true
+                value: serial
+            }
+            ListItem.SingleValue {
+                text:i18n.tr("Device")
+                Layout.fillWidth: true
+                value: deviceInfo
+            }
+            ListItem.SingleValue {
+                text:i18n.tr("Model")
+                Layout.fillWidth: true
+                value: modelInfo
+            }
+            ListItem.SingleValue {
+                text:i18n.tr("Product")
+                Layout.fillWidth: true
+                value: productInfo
+            }
+            FeatureStateItem {
+                text: "Has network connection"
+                input: hasNetworkConnection
+                inputRole: "hasNetworkConnection"
+                Layout.fillWidth: true
+                checkable: hasNetworkConnection == States.NotAvailable && !deviceItemView.deviceBusy
+            }
+            FeatureStateItem {
+                text: "Has devloper mode enabled"
+                input: developerModeEnabled
+                inputRole: "developerModeEnabled"
+                Layout.fillWidth: true
+                checkable: !deviceItemView.deviceBusy
+            }
+            ListItem.Divider{}
+
+            Label {
+                text: "Device Kits"
+                fontSize: "large"
+                anchors.left: parent.left
+            }
+            Repeater {
+                model: kits
+                delegate: ListItem.Standard {
+                    text: modelData.displayName
+                    Layout.fillWidth: true
+                    control: Button{
+                        text: "Remove"
+                        enabled: !deviceItemView.deviceBusy
+                        onClicked: devicesModel.triggerKitRemove(deviceId,modelData.id)
+                    }
+                }
+            }
+            Item {
+                clip: true
+                visible: kits.length === 0
+                Layout.minimumHeight: units.gu(25)
+                Layout.fillWidth: true
+                Label {
+                    id:label
+                    anchors.centerIn: parent
+                    anchors.bottom: button.top
+                    fontSize: "large"
+                    text: "There is currently no Kit defined for your device.\n In order to use the device in your Projects,\n you can either add a existing Kit "
+                          +"\nor let Qt Creator autocreate one for you."
+                }
+                Button {
+                    id: button
+                    anchors.left: label.left
+                    anchors.right: label.right
+                    anchors.top: label.bottom
+                    anchors.topMargin: units.gu(2)
+                    text: "Autocreate"
+                    enabled: !deviceItemView.deviceBusy
+                    onClicked: devicesModel.triggerKitAutocreate(deviceId)
+                }
+            }
+        }
+    }
+}
 
=== added file 'share/qtcreator/ubuntu/devicespage/EmulatorPage.qml'
--- share/qtcreator/ubuntu/devicespage/EmulatorPage.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/EmulatorPage.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,150 @@
+import QtQuick 2.0
+import QtQuick.Layouts 1.0
+import QtQuick.Controls 1.0 as Controls
+
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+import Ubuntu.Components.Popups 0.1
+
+Page {
+    flickable: null
+    id: myPage
+
+    Item {
+        anchors.fill: parent
+        visible: emulatorModel.busy
+
+        Column {
+            anchors.centerIn: parent
+            spacing: units.gu(1)
+
+            ActivityIndicator{
+                anchors.horizontalCenter: parent.horizontalCenter
+                running: emulatorModel.busy
+            }
+            Label {
+                text: i18n.tr("There is currently a process running in the background, please check the logs for details")
+                fontSize: "large"
+                anchors.left: parent.left
+            }
+            Button {
+                visible: emulatorModel.cancellable
+                anchors.horizontalCenter: parent.horizontalCenter
+                text: "cancel"
+                onClicked: emulatorModel.cancel()
+            }
+        }
+    }
+
+    Controls.SplitView {
+        orientation: Qt.Horizontal
+        anchors.fill: parent
+        visible: !emulatorModel.busy
+
+        Controls.SplitView {
+            orientation: Qt.Vertical
+            width: 200
+            Layout.minimumWidth: 200
+            Layout.maximumWidth: 400
+
+            Controls.ScrollView {
+                Layout.fillHeight: true
+                Layout.fillWidth: true
+
+                UbuntuListView {
+                    id: emulatorList
+                    objectName: "emulatorList"
+                    model: emulatorModel
+                    currentIndex: 0
+                    delegate: ListItem.Standard {
+                        id: delegate
+                        text: display
+                        selected: emulatorList.currentIndex == index
+                        onClicked: emulatorList.currentIndex = index
+                    }
+                }
+            }
+
+            Controls.ToolBar {
+                Layout.fillWidth: true
+                Layout.minimumHeight: units.gu(5)
+                Layout.maximumHeight: units.gu(5)
+                Row{
+                    anchors.fill: parent
+                    spacing: units.gu(2)
+                    Controls.ToolButton {
+                        text: i18n.tr("Add Emulator")
+                        tooltip: text
+                        iconSource: "qrc:/ubuntu/images/list-add.png"
+                        onClicked: PopupUtils.open(resourceRoot+"/NewEmulatorDialog.qml",myPage);
+                    }
+                    Controls.ToolButton {
+                        text: i18n.tr("Refresh emulators")
+                        tooltip: text
+                        iconSource: "qrc:/ubuntu/images/view-refresh.png"
+                        onClicked: emulatorModel.findEmulatorImages()
+                    }
+                }
+            }
+        }
+        Item {
+            id: centerItem
+            Layout.minimumWidth: units.gu(78)
+            Layout.fillWidth: true
+            property int currentIndex: emulatorList.currentIndex
+            Repeater {
+                model: emulatorModel
+                anchors.fill: parent
+                Rectangle{
+                    id: deviceItemView
+                    anchors.fill: parent
+                    anchors.margins: 12
+
+                    color: Qt.rgba(0.0, 0.0, 0.0, 0.01)
+                    visible: index == emulatorList.currentIndex && !emulatorModel.busy
+
+                    UbuntuListView {
+                        anchors.left: parent.left
+                        anchors.top: parent.top
+                        height: units.gu(50)
+                        width: units.gu(50)
+                        model: VisualItemModel {
+                            ListItem.SingleValue {
+                                text: i18n.tr("Ubuntu version")
+                                value: ubuntuVersion
+                            }
+                            ListItem.SingleValue {
+                                text: i18n.tr("Device version")
+                                value: deviceVersion
+                            }
+                            ListItem.SingleValue {
+                                text: i18n.tr("Image version")
+                                value: imageVersion
+                            }
+                            ListItem.SingleControl {
+                                control: Button {
+                                    text: "Start emulator"
+                                    onClicked: emulatorModel.startEmulator(display)
+                                }
+                            }
+                            /*
+                                    ListItem.SingleControl {
+                                        control: Button {
+                                            text: "Delete emulator"
+                                        }
+                                    }
+                                    */
+                        }
+                    }
+
+                    Label {
+                        visible: emulatorModel.busy
+                        anchors.centerIn: parent
+                        text: emulatorModel.state
+                        fontSize: "large"
+                    }
+                }
+            }
+        }
+    }
+}
 
=== added file 'share/qtcreator/ubuntu/devicespage/FeatureStateItem.qml'
--- share/qtcreator/ubuntu/devicespage/FeatureStateItem.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/FeatureStateItem.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,46 @@
+import QtQuick 2.0
+import QtQuick.Layouts 1.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+import Ubuntu.DevicesModel 0.1
+
+ListItem.Standard {
+    id: item
+    property var input: null
+    property string inputRole
+    property alias checkable: switchbox.enabled
+
+    onInputChanged: {
+        console.log("INPUT CHANGED !!!!!"+input);
+        if(input == States.Available)
+            switchbox.checked = true;
+        else
+            switchbox.checked = false;
+    }
+
+    selected: false
+    control: Row {
+        ActivityIndicator {
+            visible: input === States.Detecting
+            running: true
+        }
+        Switch {
+            id: switchbox
+            visible: input !== States.Detecting
+            checked: input === States.Available
+            enabled: checkable
+            onCheckedChanged: {
+                console.log("!!!!!!!!!!!!!!!!!!!!!!!!!!Checked changed!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+
+                if (checked && input == States.NotAvailable) {
+                    devicesModel.set(index,inputRole,true);
+                    checked = true;
+                }
+                else if ((!checked) && input == States.Available) {
+                    devicesModel.set(index,inputRole,false);
+                    checked = false;
+                }
+            }
+        }
+    }
+}
 
=== added file 'share/qtcreator/ubuntu/devicespage/LogPage.qml'
--- share/qtcreator/ubuntu/devicespage/LogPage.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/LogPage.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,24 @@
+import QtQuick 2.0
+import QtQuick.Layouts 1.0
+import QtQuick.Controls 1.0 as Controls
+
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+import Ubuntu.Components.Popups 0.1
+
+Page {
+    flickable: null
+
+    Controls.TextArea {
+        id: logTextArea
+        anchors.fill: parent
+        readOnly: true
+        textFormat: TextEdit.AutoText
+        Component.onCompleted: {
+            deviceMode.appendText.connect(appendToLog);
+        }
+        function appendToLog (txt) {
+            logTextArea.append(txt);
+        }
+    }
+}
 
=== added file 'share/qtcreator/ubuntu/devicespage/NewEmulatorDialog.qml'
--- share/qtcreator/ubuntu/devicespage/NewEmulatorDialog.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/NewEmulatorDialog.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,46 @@
+import QtQuick 2.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.Popups 0.1
+
+Dialog {
+    id: dialogue
+    title: i18n.tr("Create emulator")
+    text:  i18n.tr("Please select a name for the emulator")
+    modal: true
+    TextField {
+        id: inputName
+        placeholderText: i18n.tr("Emulator name")
+        property string lastError
+        property bool hasError
+        onTextChanged: validate()
+        Component.onCompleted: validate()
+        function validate() {
+            var result = emulatorModel.validateEmulatorName(text);
+            hasError   = !result.valid;
+            lastError  = result.error;
+        }
+    }
+    Label {
+        horizontalAlignment: Text.AlignHCenter
+        text: inputName.lastError
+        color: "red"
+        visible: inputName.hasError
+    }
+
+    Button {
+        text: "cancel"
+        onClicked: PopupUtils.close(dialogue)
+    }
+    Button {
+        text: "create"
+        color: UbuntuColors.orange
+        enabled: !inputName.hasError
+        onClicked: {
+            if(inputName.hasError)
+                return;
+            emulatorModel.createEmulatorImage(inputName.text);
+            PopupUtils.close(dialogue);
+        }
+    }
+}
+
 
=== added file 'share/qtcreator/ubuntu/devicespage/devicespage.qmlproject'
--- share/qtcreator/ubuntu/devicespage/devicespage.qmlproject	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/devicespage.qmlproject	2014-04-27 13:29:17 +0000
@@ -0,0 +1,20 @@
+/* File generated by Qt Creator, version 2.7.0 */
+
+import QmlProject 1.1
+
+Project {
+    mainFile: "devicespage.qml"
+    
+    /* Include .qml, .js, and image files from current directory and subdirectories */
+    QmlFiles {
+        directory: "."
+    }
+    JavaScriptFiles {
+        directory: "."
+    }
+    ImageFiles {
+        directory: "."
+    }
+    /* List of plugin directories passed to QML runtime */
+    // importPaths: [ "../exampleplugin" ]
+}
 
=== added directory 'share/qtcreator/ubuntu/devicespage/dummydata'
=== added file 'share/qtcreator/ubuntu/devicespage/dummydata/devicesModel.qml'
--- share/qtcreator/ubuntu/devicespage/dummydata/devicesModel.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/dummydata/devicesModel.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,52 @@
+import QtQuick 2.0
+
+ListModel {
+    id: devicesModel
+    ListElement {
+        display: "Ubuntu Device Nexus S"
+        isEmulator: false
+        connectionState: 1
+        connectionStateString: "Connected"
+        developerModeEnabled: 0
+        hasNetworkConnection: 0
+        hasWriteableImage: 1
+        hasDeveloperTools: 2
+        kits: [
+            ListElement{
+                kitId: "1"
+                displayName: "Nexus S UbuntuSDK for armhf (GCC ubuntu-sdk-14.04-trusty)"
+            }
+        ]
+        deviceLog: "<p><strong>Checking for network.....</strong><strong> </strong><br/>available</p><p><strong>Checking for readable Image....</strong><br/>not available</p>"
+    }
+    ListElement {
+        display: "Ubuntu Emulator"
+        isEmulator: true
+        connectionState: 1
+        connectionStateString: "Connected"
+        developerModeEnabled: 1
+        hasNetworkConnection: 1
+        hasWriteableImage: 1
+        hasDeveloperTools: 1
+        kits: [
+        ]
+        deviceLog: "<p><strong>Checking for network.....</strong><strong> </strong><br/>available</p><p><strong>Checking for readable Image....</strong><br/>not available</p>"
+    }
+    ListElement {
+        display: "Ubuntu Device Tablet"
+        isEmulator: false
+        connectionState: 0
+        connectionStateString: "Disconnected"
+        developerModeEnabled: 0
+        hasNetworkConnection: 0
+        hasWriteableImage: 0
+        hasDeveloperTools: 0
+        kits: [
+            ListElement{
+                kitId: "1"
+                displayName: "Tablet UbuntuSDK for armhf (GCC ubuntu-sdk-14.04-trusty)"
+            }
+        ]
+        deviceLog: "<p><strong>Checking for network.....</strong><strong> </strong><br/>available</p><p><strong>Checking for readable Image....</strong><br/>not available</p>"
+    }
+}
 
=== added file 'share/qtcreator/ubuntu/devicespage/main.qml'
--- share/qtcreator/ubuntu/devicespage/main.qml	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/main.qml	2014-04-27 13:29:17 +0000
@@ -0,0 +1,25 @@
+import QtQuick 2.0
+import Ubuntu.Components 0.1
+
+
+MainView {
+    id: modeRoot
+    width: 860
+    height: 548
+
+    Tabs {
+        Tab {
+            title: "Ubuntu Devices"
+            page: DevicePage{}
+        }
+        Tab {
+            title: "Emulators"
+            page: EmulatorPage{}
+        }
+        Tab {
+            title: "Log"
+            page: LogPage{}
+        }
+    }
+}
+
 
=== added file 'share/qtcreator/ubuntu/devicespage/test.qml#'
--- share/qtcreator/ubuntu/devicespage/test.qml#	1970-01-01 00:00:00 +0000
+++ share/qtcreator/ubuntu/devicespage/test.qml#	2014-04-27 13:29:17 +0000
@@ -0,0 +1,18 @@
+import QtQuick 2.0
+import QtQuick.Layouts 1.0
+import Ubuntu.Components 0.1
+
+MainView {
+    height: 640
+    width: 480
+
+    Page {
+        title: "Hello World"
+        ActivityIndicator {
+            anchors.fill: parent
+            visible: true
+            running: true
+        }
+    }
+
+}
 
=== modified file 'share/qtcreator/ubuntu/scripts/local_start_emulator'
--- share/qtcreator/ubuntu/scripts/local_start_emulator	2014-02-05 12:13:31 +0000
+++ share/qtcreator/ubuntu/scripts/local_start_emulator	2014-04-27 13:29:17 +0000
@@ -19,5 +19,4 @@
 ubuntu-emulator run ${EMULATOR} &
 set +e
 adb wait-for-device
-adb forward tcp:9999 tcp:22
 set -e
 
=== added file 'share/qtcreator/ubuntu/welcome/.excludes'
=== added file 'src/ubuntu/images/list-add.png'
 Binary files src/ubuntu/images/list-add.png	1970-01-01 00:00:00 +0000 and src/ubuntu/images/list-add.png	2014-04-27 13:29:17 +0000 differ
=== added file 'src/ubuntu/images/list-remove.png'
 Binary files src/ubuntu/images/list-remove.png	1970-01-01 00:00:00 +0000 and src/ubuntu/images/list-remove.png	2014-04-27 13:29:17 +0000 differ
=== added file 'src/ubuntu/images/view-refresh.png'
 Binary files src/ubuntu/images/view-refresh.png	1970-01-01 00:00:00 +0000 and src/ubuntu/images/view-refresh.png	2014-04-27 13:29:17 +0000 differ
=== modified file 'src/ubuntu/resources.qrc'
--- src/ubuntu/resources.qrc	2013-09-04 15:30:00 +0000
+++ src/ubuntu/resources.qrc	2014-04-27 13:29:17 +0000
@@ -14,5 +14,7 @@
         <file>manifest.json.template</file>
         <file>myapp.json.template</file>
         <file>manifestlib.js</file>
+        <file>images/view-refresh.png</file>
+        <file>images/list-add.png</file>
     </qresource>
 </RCC>
 
=== modified file 'src/ubuntu/ubuntu.pro'
--- src/ubuntu/ubuntu.pro	2014-04-03 12:28:13 +0000
+++ src/ubuntu/ubuntu.pro	2014-04-27 13:29:17 +0000
@@ -26,11 +26,29 @@
 RESOURCES += \
     resources.qrc
 
+#QML files
+QML_ROOT="$${PWD}/../../share/qtcreator/ubuntu"
+QML_FILES += \
+    $$QML_ROOT/welcome/welcome.qml \
+    $$QML_ROOT/welcome/Link.qml \
+    $$QML_ROOT/welcome/NewsBox.qml\
+    $$QML_ROOT/devicespage/main.qml \
+    $$QML_ROOT/devicespage/DeviceAdvancedTab.qml  \
+    $$QML_ROOT/devicespage/DeviceBuilderTab.qml  \
+    $$QML_ROOT/devicespage/DeviceLogTab.qml  \
+    $$QML_ROOT/devicespage/DevicePage.qml  \
+    $$QML_ROOT/devicespage/DeviceStatusTab.qml  \
+    $$QML_ROOT/devicespage/EmulatorPage.qml  \
+    $$QML_ROOT/devicespage/FeatureStateItem.qml  \
+    $$QML_ROOT/devicespage/NewEmulatorDialog.qml \
+    $$QML_ROOT/devicespage/LogPage.qml
+
 OTHER_FILES += \
     UbuntuProject.mimetypes.xml \
     manifest.json.template \
     myapp.json.template \
-    manifestlib.js
+    manifestlib.js \
+    $$QML_FILES
 
 SOURCES += \
     ubuntuplugin.cpp \
@@ -55,7 +73,7 @@
     ubuntuclickmanifest.cpp \
     ubuntuwebmode.cpp \
     ubuntupastebinmode.cpp \
-    ubuntudeviceswidget.cpp \
+    #ubuntudeviceswidget.cpp \
     ubuntudevicemode.cpp \
     ubuntuprocess.cpp \
     ubuntudevicenotifier.cpp \
@@ -88,7 +106,9 @@
     ubunturemotedeployconfiguration.cpp \
     ubuntulocalrunconfigurationfactory.cpp \
     ubunturemoteruncontrolfactory.cpp \
-    ubuntulocalrunconfiguration.cpp
+    ubuntulocalrunconfiguration.cpp \
+    ubuntudevicesmodel.cpp \
+    ubuntuemulatormodel.cpp
 
 HEADERS += \
     ubuntuplugin.h \
@@ -117,7 +137,7 @@
     ubuntuwebmode.h \
     ubuntupastebinmode.h \
     ubuntudevicemode.h \
-    ubuntudeviceswidget.h \
+    #ubuntudeviceswidget.h \
     ubuntuprocess.h \
     ubuntudevicenotifier.h \
     ubuntusettingspage.h \
@@ -149,5 +169,7 @@
     ubunturemotedeployconfiguration.h \
     ubuntulocalrunconfigurationfactory.h \
     ubunturemoteruncontrolfactory.h \
-    ubuntulocalrunconfiguration.h
+    ubuntulocalrunconfiguration.h \
+    ubuntudevicesmodel.h \
+    ubuntuemulatormodel.h
 
 
=== modified file 'src/ubuntu/ubuntuconstants.h'
--- src/ubuntu/ubuntuconstants.h	2014-04-10 15:59:28 +0000
+++ src/ubuntu/ubuntuconstants.h	2014-04-27 13:29:17 +0000
@@ -120,7 +120,7 @@
 const char UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR[] = "Creating new emulator instance.";
 const char UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR_SCRIPT[] = "%0/local_create_emulator %1 %2";
 const char UBUNTUDEVICESWIDGET_LOCAL_START_EMULATOR[] = "Starting the selected emulator.";
-const char UBUNTUDEVICESWIDGET_LOCAL_START_EMULATOR_SCRIPT[] = "%0/local_start_emulator %1";
+const char UBUNTUDEVICESWIDGET_LOCAL_START_EMULATOR_SCRIPT[] = "%0/local_start_emulator";
 
 
 const char UBUNTUDEVICESWIDGET_STARTSSHSERVICE[] = "Start ssh service on device..";
@@ -213,7 +213,7 @@
 const char UBUNTUDEVICESWIDGET_DETECTOPENSSH[] = "Detecting if openssh-server is installed..";
 const char UBUNTUDEVICESWIDGET_DETECTOPENSSH_SCRIPT[] = "%0/openssh_version %1";
 const char UBUNTUDEVICESWIDGET_DETECTDEVICES[] = "Detecting device..";
-const char UBUNTUDEVICESWIDGET_DETECTDEVICES_SCRIPT[] = "%0/device_search %1";
+const char UBUNTUDEVICESWIDGET_DETECTDEVICES_SCRIPT[] = "%0/device_search";
 const char UBUNTUDEVICESWIDGET_SSHCONNECT_SCRIPT[] = "%0/openssh_connect";
 const char UBUNTUDEVICESWIDGET_SSHCONNECT[] = "Opening ssh connection to device";
 
@@ -241,6 +241,8 @@
 #endif
 
 const QString UBUNTU_WELCOMESCREEN_QML = UBUNTU_RESOURCE_PATH + QLatin1String("/ubuntu/welcome/welcome.qml");
+const QString UBUNTU_DEVICESCREEN_QML  = UBUNTU_RESOURCE_PATH + QLatin1String("/ubuntu/devicespage/main.qml");
+const QString UBUNTU_DEVICESCREEN_ROOT  = UBUNTU_RESOURCE_PATH + QLatin1String("/ubuntu/devicespage");
 const QString UBUNTU_TEMPLATESPATH = UBUNTU_RESOURCE_PATH + QLatin1String("/templates/wizards/ubuntu/");
 const QString UBUNTU_MENUPATH = UBUNTU_RESOURCE_PATH + QLatin1String("/ubuntu/");
 const QString UBUNTU_SHAREPATH = UBUNTU_RESOURCE_PATH + QLatin1String("/ubuntu/");
 
=== modified file 'src/ubuntu/ubuntudevice.cpp'
--- src/ubuntu/ubuntudevice.cpp	2014-04-10 19:03:23 +0000
+++ src/ubuntu/ubuntudevice.cpp	2014-04-27 13:29:17 +0000
@@ -24,6 +24,7 @@
 #include "localportsmanager.h"
 
 #include <projectexplorer/devicesupport/devicemanager.h>
+#include <remotelinux/genericlinuxdeviceconfigurationwidget.h>
 #include <coreplugin/messagemanager.h>
 #include <ssh/sshconnection.h>
 #include <utils/portlist.h>
@@ -32,11 +33,15 @@
 #include <QCoreApplication>
 #include <QDir>
 #include <QDebug>
+#include <QRegularExpression>
 
 namespace Ubuntu {
 namespace Internal {
 
 const QLatin1String DEVICE_INFO_KEY("UbuntuDevice.InfoString");
+const QLatin1String DEVICE_PRODUCT_INFO_KEY("UbuntuDevice.Product.InfoString");
+const QLatin1String DEVICE_MODEL_INFO_KEY("UbuntuDevice.Model.InfoString");
+const QLatin1String DEVICE_DEVICE_INFO_KEY("UbuntuDevice.Device.InfoString");
 
 /*!
  * \class UbuntuDeviceHelper
@@ -125,8 +130,8 @@
                 m_clonedNwCount = 0;
                 if(m_dev->m_hasNetworkConnection != UbuntuDevice::Available) {
                     m_dev->m_hasNetworkConnection = UbuntuDevice::Available;
-                    emit featureDetected();
                 }
+                emit featureDetected();
                 detectOpenSsh();
 
             } else {
@@ -137,9 +142,9 @@
                     //we tried to enable network and failed
                     if(m_dev->m_hasNetworkConnection != UbuntuDevice::NotAvailable) {
                         m_dev->m_hasNetworkConnection = UbuntuDevice::NotAvailable;
-                        emit featureDetected();
-                        emit deviceNeedsSetup();
                     }
+                    emit featureDetected();
+                    emit deviceNeedsSetup();
                     //detect other features
                     detectOpenSsh();
                 }
@@ -157,8 +162,8 @@
 
                 if(m_dev->m_hasOpenSSHServer != UbuntuDevice::Available) {
                     m_dev->m_hasOpenSSHServer = UbuntuDevice::Available;
-                    emit featureDetected();
                 }
+                emit featureDetected();
 
                 ProjectExplorer::DeviceManager::instance()->setDeviceState(m_dev->id(),ProjectExplorer::IDevice::DeviceConnected);
                 endAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_SSH_IS_INSTALLED).arg(m_reply.trimmed()));
@@ -170,9 +175,9 @@
 
                 if(m_dev->m_hasOpenSSHServer != UbuntuDevice::NotAvailable) {
                     m_dev->m_hasOpenSSHServer = UbuntuDevice::NotAvailable;
-                    emit featureDetected();
-                    emit deviceNeedsSetup();
                 }
+                emit featureDetected();
+                emit deviceNeedsSetup();
 
                 endAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_SSH_NOT_INSTALLED));
 
@@ -242,7 +247,6 @@
                 m_dev->m_hasDeveloperTools = UbuntuDevice::Available;
                 endAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_DEVELOPERTOOLS_INSTALLED));
             }
-
             emit featureDetected();
             break;
         }
@@ -297,6 +301,10 @@
 void UbuntuDeviceHelper::detectOpenSsh()
 {
     setProcessState(UbuntuDevice::DetectOpenSSH);
+
+    m_dev->m_hasOpenSSHServer = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_DETECTOPENSSH));
 
     stopProcess();
@@ -323,6 +331,9 @@
     setProcessState(UbuntuDevice::InstallOpenSSH);
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_SSH_INSTALL));
 
+    m_dev->m_hasOpenSSHServer = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     stopProcess();
 
     startProcess(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_SSH_INSTALL_SCRIPT)
@@ -335,6 +346,9 @@
     setProcessState(UbuntuDevice::RemoveOpenSSH);
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_SSH_REMOVE));
 
+    m_dev->m_hasOpenSSHServer = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     stopProcess();
 
     startProcess(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_SSH_REMOVE_SCRIPT)
@@ -348,6 +362,10 @@
     //          adb shell nmcli dev list iface <intfc> | grep IP4.ADDRESS
     //      to find out the devices ip address
     setProcessState(UbuntuDevice::DetectNetworkConnection);
+
+    m_dev->m_hasNetworkConnection = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_HASNETWORK));
 
     stopProcess();
@@ -372,6 +390,10 @@
 void UbuntuDeviceHelper::detectDeviceWritableImage()
 {
     setProcessState(UbuntuDevice::DetectDeviceWriteableImage);
+
+    m_dev->m_hasWriteableImage = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_DETECTWRITABLEIMAGE));
 
     stopProcess();
@@ -384,6 +406,10 @@
 void UbuntuDeviceHelper::detectDeveloperTools()
 {
     setProcessState(UbuntuDevice::DetectDeveloperTools);
+
+    m_dev->m_hasDeveloperTools = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_DETECTDEVELOPERTOOLS));
 
     stopProcess();
@@ -503,6 +529,9 @@
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_MAKEFSWRITABLE));
     stopProcess();
 
+    m_dev->m_hasWriteableImage = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     startProcess(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_MAKEFSWRITABLE_SCRIPT)
                  .arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH)
                  .arg(m_dev->id().toSetting().toString()));
@@ -517,6 +546,9 @@
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_MAKEFSREADONLY));
     stopProcess();
 
+    m_dev->m_hasWriteableImage = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     startProcess(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_MAKEFSREADONLY_SCRIPT)
                  .arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH)
                  .arg(m_dev->id().toSetting().toString()));
@@ -589,6 +621,9 @@
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_ENABLEPLATFORMDEVELOPMENT));
     stopProcess();
 
+    m_dev->m_hasDeveloperTools = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     startProcess(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_ENABLEPLATFORMDEVELOPMENT_SCRIPT)
                  .arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH)
                  .arg(m_dev->id().toSetting().toString()));
@@ -604,6 +639,9 @@
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_DISABLEPLATFORMDEVELOPMENT));
     stopProcess();
 
+    m_dev->m_hasDeveloperTools = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     startProcess(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_DISABLEPLATFORMDEVELOPMENT_SCRIPT)
                  .arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH)
                  .arg(m_dev->id().toSetting().toString()));
@@ -630,9 +668,13 @@
 void UbuntuDeviceHelper::cloneNetwork()
 {
     m_clonedNwCount++;
+
     setProcessState(UbuntuDevice::CloneNetwork);
     beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_CLONENETWORK));
 
+    m_dev->m_hasNetworkConnection = UbuntuDevice::Unknown;
+    emit featureDetected();
+
     stopProcess();
     startProcess(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_CLONENETWORK_SCRIPT)
                  .arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH)
@@ -709,7 +751,9 @@
     : LinuxDevice(other)
     , m_helper(new UbuntuDeviceHelper(this))
     , m_processState(NotStarted)
-    , m_deviceInfoString(other.deviceInfoString())
+    , m_deviceInfo(other.m_deviceInfo)
+    , m_modelInfo(other.m_modelInfo)
+    , m_productInfo(other.m_productInfo)
 {
     setDeviceState(ProjectExplorer::IDevice::DeviceDisconnected);
     setupPrivateKey();
@@ -772,6 +816,11 @@
     return m_helper;
 }
 
+void UbuntuDevice::cloneNetwork()
+{
+    m_helper->cloneNetwork();
+}
+
 /*!
  * \brief UbuntuDevice::openTerminal
  * Opens a detached terminal, logged into the device
@@ -898,14 +947,48 @@
         m_helper->removeDevTools();
 }
 
-void UbuntuDevice::setDeviceInfoString(const QString &info)
-{
-    m_deviceInfoString = info;
-}
-
-QString UbuntuDevice::deviceInfoString() const
-{
-    return m_deviceInfoString;
+void UbuntuDevice::setDeviceInfoString(const QString &deviceInfo)
+{
+    m_productInfo = tr("unknown");
+    m_modelInfo   = m_productInfo;
+    m_deviceInfo  = m_productInfo;
+
+    QRegularExpression expr(QStringLiteral("product:\\s?(\\w+)"));
+    QRegularExpressionMatch m = expr.match(deviceInfo);
+    if(m.hasMatch())
+        m_productInfo = m.captured(1);
+
+    expr.setPattern(QStringLiteral("model:\\s?(\\w+)"));
+    m = expr.match(deviceInfo);
+    if(m.hasMatch())
+        m_modelInfo = m.captured(1);
+
+    expr.setPattern(QStringLiteral("device:\\s?(\\w+)"));
+    m = expr.match(deviceInfo);
+    if(m.hasMatch())
+        m_deviceInfo = m.captured(1);
+}
+
+void UbuntuDevice::setDeviceInfo(const QString &productInfo, const QString &modelInfo, const QString &deviceInfo)
+{
+    m_productInfo = productInfo;
+    m_modelInfo = modelInfo;
+    m_deviceInfo = deviceInfo;
+}
+
+QString UbuntuDevice::modelInfo() const
+{
+    return m_modelInfo;
+}
+
+QString UbuntuDevice::deviceInfo() const
+{
+    return m_deviceInfo;
+}
+
+QString UbuntuDevice::productInfo() const
+{
+    return m_productInfo;
 }
 
 UbuntuDevice::FeatureState UbuntuDevice::hasNetworkConnection() const
@@ -968,14 +1051,15 @@
         case RemoveDevTools:
             return tr("Removing development tools");
         case Done:
-            return tr("Finished");
+            return tr("Ready");
     }
     return QString();
 }
 
 ProjectExplorer::IDeviceWidget *UbuntuDevice::createWidget()
 {
-    return new UbuntuDeviceConfigurationWidget(sharedFromThis());
+    return new RemoteLinux::GenericLinuxDeviceConfigurationWidget(sharedFromThis());
+    //return new UbuntuDeviceConfigurationWidget(sharedFromThis());
 }
 
 QList<Core::Id> UbuntuDevice::actionIds() const
@@ -996,8 +1080,27 @@
 void UbuntuDevice::fromMap(const QVariantMap &map)
 {
     LinuxDevice::fromMap(map);
+
+    //legacy setting, will be converted to the new settings on the next save
     if(map.contains(DEVICE_INFO_KEY))
-        m_deviceInfoString = map[DEVICE_INFO_KEY].toString();
+        setDeviceInfoString(map[DEVICE_INFO_KEY].toString());
+    else {
+        QString unknown = tr("unknown");
+        if(map.contains(DEVICE_DEVICE_INFO_KEY))
+            m_deviceInfo = map[DEVICE_DEVICE_INFO_KEY].toString();
+        else
+            m_deviceInfo = unknown;
+
+        if(map.contains(DEVICE_MODEL_INFO_KEY))
+            m_modelInfo = map[DEVICE_MODEL_INFO_KEY].toString();
+        else
+            m_modelInfo = unknown;
+
+        if(map.contains(DEVICE_PRODUCT_INFO_KEY))
+            m_productInfo = map[DEVICE_PRODUCT_INFO_KEY].toString();
+        else
+            m_productInfo = unknown;
+    }
 
     setupPrivateKey();
     m_helper->init();
@@ -1006,7 +1109,9 @@
 QVariantMap UbuntuDevice::toMap() const
 {
     QVariantMap map = LinuxDevice::toMap();
-    map.insert(DEVICE_INFO_KEY,m_deviceInfoString);
+    map.insert(DEVICE_PRODUCT_INFO_KEY,m_productInfo);
+    map.insert(DEVICE_MODEL_INFO_KEY,m_modelInfo);
+    map.insert(DEVICE_DEVICE_INFO_KEY,m_deviceInfo);
     return map;
 }
 
 
=== modified file 'src/ubuntu/ubuntudevice.h'
--- src/ubuntu/ubuntudevice.h	2014-04-10 15:59:28 +0000
+++ src/ubuntu/ubuntudevice.h	2014-04-27 13:29:17 +0000
@@ -36,7 +36,6 @@
 {
     Q_OBJECT
     friend class UbuntuDevice;
-
 public:
     explicit UbuntuDeviceHelper(UbuntuDevice* dev);
     ~UbuntuDeviceHelper();
@@ -150,6 +149,7 @@
     QString serialNumber () const;
     UbuntuDeviceHelper *helper () const;
 
+    void cloneNetwork    ();
     void openTerminal    ();
     void cloneTimeConfig ();
     void enablePortForward ();
@@ -162,8 +162,11 @@
     void setWriteableImageEnabled    ( const bool enabled = true );
     void setDeveloperToolsInstalled  ( const bool installed = true );
 
-    void setDeviceInfoString (const QString &info);
-    QString deviceInfoString () const;
+    void setDeviceInfoString (const QString &deviceInfo);
+    void setDeviceInfo (const QString &productInfo, const QString &modelInfo, const QString &deviceInfo);
+    QString modelInfo() const;
+    QString deviceInfo() const;
+    QString productInfo() const;
 
     FeatureState developerModeEnabled () const;
     FeatureState hasNetworkConnection () const;
@@ -198,7 +201,9 @@
     FeatureState    m_hasWriteableImage;
     FeatureState    m_hasDeveloperTools;
     ProcessState    m_processState;
-    QString         m_deviceInfoString;
+    QString         m_modelInfo;
+    QString         m_deviceInfo;
+    QString         m_productInfo;
     Utils::PortList m_localForwardedPorts;
 
 private:
 
=== modified file 'src/ubuntu/ubuntudevicemode.cpp'
--- src/ubuntu/ubuntudevicemode.cpp	2013-09-04 15:30:00 +0000
+++ src/ubuntu/ubuntudevicemode.cpp	2014-04-27 13:29:17 +0000
@@ -18,6 +18,8 @@
 
 #include "ubuntudevicemode.h"
 #include "ubuntuconstants.h"
+#include "ubuntudevicesmodel.h"
+#include "ubuntuemulatormodel.h"
 
 #include <coreplugin/modemanager.h>
 #include <coreplugin/editormanager/editormanager.h>
@@ -29,18 +31,30 @@
 #include <utils/styledbar.h>
 #include <QVBoxLayout>
 #include <QScrollArea>
+#include <QQuickView>
+#include <QQmlContext>
+#include <QQmlEngine>
+#include <QDebug>
 
 using namespace Ubuntu::Internal;
 
+UbuntuDeviceMode *UbuntuDeviceMode::m_instance = 0;
+
 UbuntuDeviceMode::UbuntuDeviceMode(QObject *parent) :
     Core::IMode(parent)
 {
+    Q_ASSERT_X(m_instance == 0, Q_FUNC_INFO,"There can be only one instance of UbuntuDeviceMode");
+    m_instance = this;
+
+    m_qmlControl = new UbuntuQMLDeviceMode(this);
+
     setDisplayName(tr(Ubuntu::Constants::UBUNTU_MODE_DEVICES_DISPLAYNAME));
     setIcon(QIcon(QLatin1String(Ubuntu::Constants::UBUNTU_MODE_DEVICES_ICON)));
     setPriority(Ubuntu::Constants::UBUNTU_MODE_DEVICES_PRIORITY);
     setId(Ubuntu::Constants::UBUNTU_MODE_DEVICES);
     setObjectName(QLatin1String(Ubuntu::Constants::UBUNTU_MODE_DEVICES));
 
+
     m_modeWidget = new QWidget;
     QVBoxLayout *layout = new QVBoxLayout;
     layout->setMargin(0);
@@ -49,22 +63,90 @@
 
     Utils::StyledBar* styledBar = new Utils::StyledBar(m_modeWidget);
     layout->addWidget(styledBar);
-    QScrollArea *scrollArea = new QScrollArea(m_modeWidget);
-    scrollArea->setFrameShape(QFrame::NoFrame);
-    layout->addWidget(scrollArea);
-    scrollArea->setWidget(&m_ubuntuDevicesWidget);
-    scrollArea->setWidgetResizable(true);
+
+    m_modeView = new QQuickView;
+    m_modeView->setResizeMode(QQuickView::SizeRootObjectToView);
+    m_devicesModel = new UbuntuDevicesModel(m_modeView);
+    m_emulatorModel = new UbuntuEmulatorModel(m_modeView);
+
+    connect(m_devicesModel,SIGNAL(stdOutMessage(QString)),m_qmlControl,SLOT(addText(QString)));
+    connect(m_devicesModel,SIGNAL(stdErrMessage(QString)),m_qmlControl,SLOT(addErrorText(QString)));
+    connect(m_emulatorModel,SIGNAL(logMessage(QString)),m_qmlControl,SLOT(addText(QString)));
+    connect(m_emulatorModel,SIGNAL(stdOutMessage(QString)),m_qmlControl,SLOT(addText(QString)));
+    connect(m_emulatorModel,SIGNAL(stdErrMessage(QString)),m_qmlControl,SLOT(addErrorText(QString)));
+
+    QWidget* container = QWidget::createWindowContainer(m_modeView);
+    container->setMinimumWidth(860);
+    container->setMinimumHeight(548);
+    container->setFocusPolicy(Qt::TabFocus);
+    layout->addWidget(container);
+
+    m_modeView->rootContext()->setContextProperty(QLatin1String("devicesModel") ,m_devicesModel);
+    m_modeView->rootContext()->setContextProperty(QLatin1String("emulatorModel"),m_emulatorModel);
+    m_modeView->rootContext()->setContextProperty(QLatin1String("deviceMode")   ,m_qmlControl);
+    m_modeView->rootContext()->setContextProperty(QLatin1String("resourceRoot") ,Constants::UBUNTU_DEVICESCREEN_ROOT);
+    m_modeView->setSource(QUrl::fromLocalFile(Constants::UBUNTU_DEVICESCREEN_QML));
 
     connect(Core::ModeManager::instance(), SIGNAL(currentModeChanged(Core::IMode*)), SLOT(modeChanged(Core::IMode*)));
-
     setWidget(m_modeWidget);
 }
 
-void UbuntuDeviceMode::modeChanged(Core::IMode *mode) {
-
+UbuntuDevice::ConstPtr UbuntuDeviceMode::device()
+{
+    if(m_devicesModel->rowCount() <= 0)
+        return UbuntuDevice::ConstPtr();
+
+    if(!m_deviceIndex.isValid()) {
+        m_deviceIndex = 0; //device 0 is always the first selected
+    }
+    return m_devicesModel->device(m_deviceIndex.toInt());
+}
+
+void UbuntuDeviceMode::deviceSelected(const QVariant index)
+{
+    m_deviceIndex = index;
+    emit updateDeviceActions ();
+}
+
+void UbuntuDeviceMode::modeChanged(Core::IMode *mode)
+{
+    Q_UNUSED(mode);
 }
 
 void UbuntuDeviceMode::initialize() {
 
-
+}
+
+UbuntuDeviceMode *UbuntuDeviceMode::instance()
+{
+    return m_instance;
+}
+
+
+UbuntuQMLDeviceMode::UbuntuQMLDeviceMode(UbuntuDeviceMode *parent)
+    : QObject(parent),
+      m_mode(parent)
+{
+
+}
+
+void UbuntuQMLDeviceMode::deviceSelected(const QVariant index)
+{
+    m_mode->deviceSelected(index);
+}
+
+void UbuntuQMLDeviceMode::addText(const QString &arg)
+{
+    QString in = arg;
+    in.replace(QStringLiteral("\n"),QStringLiteral("<br>"));
+    emit appendText(in);
+}
+
+void UbuntuQMLDeviceMode::addErrorText(const QString &error)
+{
+    QString in = error;
+    in.replace(QStringLiteral("\n"),QStringLiteral("<br>"));
+    in.prepend(QStringLiteral("<font color=\"#FF0000\">"));
+    in.append(QStringLiteral("</font>"));
+    emit appendText(in);
 }
 
=== modified file 'src/ubuntu/ubuntudevicemode.h'
--- src/ubuntu/ubuntudevicemode.h	2013-09-04 15:30:00 +0000
+++ src/ubuntu/ubuntudevicemode.h	2014-04-27 13:29:17 +0000
@@ -19,12 +19,38 @@
 #ifndef UBUNTUDEVICEMODE_H
 #define UBUNTUDEVICEMODE_H
 
+#include "ubuntudevice.h"
 #include <coreplugin/imode.h>
-#include "ubuntudeviceswidget.h"
+
+class QQuickView;
 
 namespace Ubuntu {
 namespace Internal {
 
+class UbuntuDevicesModel;
+class UbuntuEmulatorModel;
+class UbuntuDeviceMode;
+
+class UbuntuQMLDeviceMode : public QObject {
+    Q_OBJECT
+
+public:
+    UbuntuQMLDeviceMode( UbuntuDeviceMode *parent );
+
+public slots:
+    void deviceSelected ( const QVariant index );
+    void addText (const QString &arg);
+    void addErrorText (const QString &error);
+
+signals:
+    void logChanged(const QString &arg);
+    void appendText(const QString &newText);
+
+private:
+    UbuntuDeviceMode* m_mode;
+};
+
+
 class UbuntuDeviceMode : public Core::IMode
 {
     Q_OBJECT
@@ -33,12 +59,26 @@
     UbuntuDeviceMode(QObject *parent = 0);
     void initialize();
 
+    static UbuntuDeviceMode *instance();
+    UbuntuDevice::ConstPtr device();
+
+    void deviceSelected ( const QVariant index );
+
+signals:
+    void updateDeviceActions ();
+
 protected slots:
     void modeChanged(Core::IMode*);
 
 protected:
+    static UbuntuDeviceMode *m_instance;
+    UbuntuDevicesModel  *m_devicesModel;
+    UbuntuEmulatorModel *m_emulatorModel;
+    UbuntuQMLDeviceMode *m_qmlControl;
+    QQuickView *m_modeView;
     QWidget* m_modeWidget;
-    UbuntuDevicesWidget m_ubuntuDevicesWidget;
+    QVariant m_deviceIndex;
+    QString  m_log;
 };
 
 
 
=== added file 'src/ubuntu/ubuntudevicesmodel.cpp'
--- src/ubuntu/ubuntudevicesmodel.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntudevicesmodel.cpp	2014-04-27 13:29:17 +0000
@@ -0,0 +1,734 @@
+#include "ubuntudevicesmodel.h"
+#include "ubuntuconstants.h"
+#include "ubuntukitmanager.h"
+
+#include <projectexplorer/devicesupport/devicemanager.h>
+#include <projectexplorer/kitmanager.h>
+#include <projectexplorer/kit.h>
+#include <projectexplorer/kitinformation.h>
+
+#include <QCoreApplication>
+#include <QRegularExpression>
+#include <QRegularExpressionMatch>
+#include <QVariant>
+
+namespace Ubuntu {
+namespace Internal {
+
+UbuntuDevicesModel::UbuntuDevicesModel(QObject *parent) :
+    QAbstractListModel(parent)
+{
+    m_deviceNotifier = new UbuntuDeviceNotifier(this);
+    connect(m_deviceNotifier,SIGNAL(deviceConnected(QString)),this,SLOT(deviceConnected(QString)));
+
+    m_adbProcess = new QProcess(this);
+    connect(m_adbProcess,SIGNAL(finished(int)),this,SLOT(refreshFinished(int)));
+    connect(m_adbProcess,SIGNAL(readyRead()),this,SLOT(adbReadyRead()));
+
+
+    ProjectExplorer::KitManager* devMgr = static_cast<ProjectExplorer::KitManager*>(ProjectExplorer::KitManager::instance());
+    connect(devMgr,SIGNAL(kitsLoaded()),this,SLOT(refresh()));
+    connect(ProjectExplorer::DeviceManager::instance(),SIGNAL(deviceListReplaced()),this,SLOT(readDevicesFromSettings()));
+}
+
+bool UbuntuDevicesModel::set(int index, const QString &role, const QVariant &value)
+{
+    if(index < 0 || index >= rowCount())
+        return false;
+
+    QModelIndex idx = createIndex(index,0);
+    if(!roleNames().values().contains(role.toUtf8()))
+        return false;
+
+    return setData(idx,value,roleNames().key(role.toUtf8()));
+}
+
+int UbuntuDevicesModel::rowCount(const QModelIndex &parent) const
+{
+    if(parent.isValid())
+        return 0;
+    return m_knownDevices.size();
+}
+
+bool UbuntuDevicesModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+    qDebug()<<"Setting index "<<index<<" with data "<<value<<" to role "<<role;
+    if(!index.isValid()
+            || index.parent().isValid()
+            || index.row() < 0
+            || index.row() > rowCount())
+        return false;
+
+    UbuntuDevice::Ptr dev = m_knownDevices[index.row()]->device();
+
+    switch (role) {
+        case Qt::DisplayRole:
+        case Qt::EditRole:
+            return false;
+        case KitListRole:
+            return false;
+        case DeveloperModeRole: {
+            if(!value.type() == QVariant::Bool)
+                return false;
+
+            bool set = value.toBool();
+            UbuntuDevice::FeatureState newState = set ? UbuntuDevice::Available : UbuntuDevice::NotAvailable;
+            UbuntuDevice::FeatureState oldState = dev->developerModeEnabled();
+
+            if(oldState == UbuntuDevice::Unknown)
+                return false;
+
+            if( oldState != newState )
+                dev->setDeveloperModeEnabled(set);
+            return true;
+            break;
+        }
+        case NetworkConnectionRole: {
+            if(!value.type() == QVariant::Bool)
+                return false;
+
+            bool set = value.toBool();
+            UbuntuDevice::FeatureState oldState = dev->hasNetworkConnection();
+
+            if( oldState == UbuntuDevice::Unknown || oldState == UbuntuDevice::Available )
+                return false;
+
+            if(set)
+                dev->cloneNetwork();
+            return true;
+
+            break;
+        }
+        case WriteableImageRole: {
+            if(!value.type() == QVariant::Bool)
+                return false;
+
+            bool set = value.toBool();
+            UbuntuDevice::FeatureState newState = set ? UbuntuDevice::Available : UbuntuDevice::NotAvailable;
+            UbuntuDevice::FeatureState oldState = dev->hasWriteableImage();
+
+            if(oldState == UbuntuDevice::Unknown)
+                return false;
+
+            if( oldState != newState )
+                dev->setWriteableImageEnabled(set);
+            return true;
+            break;
+        }
+        case DeveloperToolsRole: {
+            if(!value.type() == QVariant::Bool)
+                return false;
+
+            bool set = value.toBool();
+            UbuntuDevice::FeatureState newState = set ? UbuntuDevice::Available : UbuntuDevice::NotAvailable;
+            UbuntuDevice::FeatureState oldState = dev->hasDeveloperTools();
+
+            if(oldState == UbuntuDevice::Unknown)
+                return false;
+
+            if( oldState != newState )
+                dev->setDeveloperToolsInstalled(set);
+            return true;
+            break;
+        }
+        default:
+            break;
+    }
+
+    return false;
+}
+
+QVariant UbuntuDevicesModel::data(const QModelIndex &index, int role) const
+{
+    if(!index.isValid()
+            || index.parent().isValid()
+            || index.row() < 0
+            || index.row() > rowCount())
+        return QVariant();
+
+    switch (role) {
+        case Qt::DisplayRole:
+        case Qt::EditRole:
+            return m_knownDevices[index.row()]->device()->displayName();
+        case UniqueIdRole:
+            return m_knownDevices[index.row()]->id().uniqueIdentifier();
+        case DetectionStateRole:
+            return m_knownDevices[index.row()]->device()->detectionState();
+        case DetectionStateStringRole:
+            return m_knownDevices[index.row()]->device()->detectionStateString();
+        case ConnectionStateRole:
+            return m_knownDevices[index.row()]->device()->deviceState();
+        case ConnectionStateStringRole:
+            return m_knownDevices[index.row()]->device()->deviceStateToString();
+        case KitListRole:
+            return QVariant::fromValue(m_knownDevices[index.row()]->kits());
+        case DeveloperModeRole:
+            return m_knownDevices[index.row()]->device()->developerModeEnabled();
+        case NetworkConnectionRole:
+            return m_knownDevices[index.row()]->device()->hasNetworkConnection();
+        case WriteableImageRole:
+            return m_knownDevices[index.row()]->device()->hasWriteableImage();
+        case DeveloperToolsRole:
+            return m_knownDevices[index.row()]->device()->hasDeveloperTools();
+        case EmulatorRole:
+            return false;
+        case LogRole:
+            return m_knownDevices[index.row()]->device()->helper()->log();
+        case SerialIdRole:
+            return m_knownDevices[index.row()]->device()->id().toSetting();
+        case ModelInfoRole:
+            return m_knownDevices[index.row()]->device()->modelInfo();
+        case DeviceInfoRole:
+            return m_knownDevices[index.row()]->device()->deviceInfo();
+        case ProductInfoRole:
+            return m_knownDevices[index.row()]->device()->productInfo();
+        default:
+            break;
+    }
+
+    return QVariant();
+}
+
+QHash<int, QByteArray> UbuntuDevicesModel::roleNames() const
+{
+    QHash<int,QByteArray> roles = QAbstractListModel::roleNames();
+    roles.insert(UniqueIdRole,"deviceId");
+    roles.insert(DetectionStateRole,"detectionState");
+    roles.insert(DetectionStateStringRole,"detectionStateString");
+    roles.insert(ConnectionStateRole,"connectionState");
+    roles.insert(ConnectionStateStringRole,"connectionStateString");
+    roles.insert(KitListRole,"kits");
+    roles.insert(DeveloperModeRole,"developerModeEnabled");
+    roles.insert(NetworkConnectionRole,"hasNetworkConnection");
+    roles.insert(WriteableImageRole,"hasWriteableImage");
+    roles.insert(DeveloperToolsRole,"hasDeveloperTools");
+    roles.insert(EmulatorRole,"isEmulator");
+    roles.insert(LogRole,"deviceLog");
+    roles.insert(SerialIdRole,"serial");
+    roles.insert(ModelInfoRole,"modelInfo");
+    roles.insert(DeviceInfoRole,"deviceInfo");
+    roles.insert(ProductInfoRole,"productInfo");
+    return roles;
+}
+
+Qt::ItemFlags UbuntuDevicesModel::flags(const QModelIndex &index) const
+{
+    return QAbstractListModel::flags(index) | Qt::ItemIsEditable;
+}
+
+void UbuntuDevicesModel::triggerCloneTimeConfig(const int devId)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+    m_knownDevices[row]->device()->cloneTimeConfig();
+}
+
+void UbuntuDevicesModel::triggerPortForwarding(const int devId)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+    m_knownDevices[row]->device()->enablePortForward();
+}
+
+void UbuntuDevicesModel::triggerSSHSetup(const int devId)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+    m_knownDevices[row]->device()->deployPublicKey();
+}
+
+void UbuntuDevicesModel::triggerSSHConnection(const int devId)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+    m_knownDevices[row]->device()->openTerminal();
+}
+
+void UbuntuDevicesModel::triggerReboot(const int devId)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+    m_knownDevices[row]->device()->reboot();
+}
+
+void UbuntuDevicesModel::triggerRebootBootloader(const int devId)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+    m_knownDevices[row]->device()->rebootToBootloader();
+}
+
+void UbuntuDevicesModel::triggerRebootRecovery(const int devId)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+    m_knownDevices[row]->device()->rebootToRecovery();
+}
+
+void UbuntuDevicesModel::triggerShutdown(const int devId)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+    m_knownDevices[row]->device()->shutdown();
+}
+
+void UbuntuDevicesModel::triggerKitAutocreate(const int devId)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+    UbuntuKitManager::autoCreateKit(m_knownDevices[row]->device());
+}
+
+void UbuntuDevicesModel::triggerKitRemove(const int devId, const QVariant &kitid)
+{
+    int row = findDevice(devId);
+    if(row < 0)
+        return;
+
+    ProjectExplorer::Kit* k = ProjectExplorer::KitManager::find(Core::Id::fromSetting(kitid));
+    if(ProjectExplorer::DeviceKitInformation::deviceId(k) == Core::Id(devId)) {
+        //completely delete the kit
+        ProjectExplorer::KitManager::deregisterKit(k);
+    }
+}
+
+void UbuntuDevicesModel::refresh()
+{
+    if( m_adbProcess->state() != QProcess::NotRunning ) {
+        //make sure we use a clean QProcess
+        m_adbProcess->disconnect(this);
+        m_adbProcess->kill();
+        m_adbProcess->deleteLater();
+
+        m_adbProcess = new QProcess(this);
+        connect(m_adbProcess,SIGNAL(finished(int)),this,SLOT(refreshFinished(int)));
+        connect(m_adbProcess,SIGNAL(readyRead()),this,SLOT(adbReadyRead()));
+    }
+    bool restartAdb = true;
+    m_adbProcess->setWorkingDirectory(QCoreApplication::applicationDirPath());
+    QStringList args = QStringList() << (restartAdb ? QString::number(1) : QString::number(0));
+    m_adbProcess->start(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_DETECTDEVICES_SCRIPT)
+                          .arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH),args);
+
+    clear();
+}
+
+void UbuntuDevicesModel::clear()
+{
+    if(rowCount()) {
+        beginRemoveRows(QModelIndex(),0,rowCount()-1);
+        qDeleteAll(m_knownDevices.begin(),m_knownDevices.end());
+        m_knownDevices.clear();
+        endRemoveRows();
+    }
+}
+
+int UbuntuDevicesModel::findDevice(int uniqueIdentifier) const
+{
+    for ( int i = 0; i < m_knownDevices.size(); i++ ) {
+        if(m_knownDevices[i]->id().uniqueIdentifier() == uniqueIdentifier)
+            return i;
+    }
+    return -1;
+}
+
+bool UbuntuDevicesModel::hasDevice(int uniqueIdentifier) const
+{
+    return findDevice(uniqueIdentifier) >= 0;
+}
+
+UbuntuDevice::ConstPtr UbuntuDevicesModel::device(const int index)
+{
+    if(index < 0 || index >= rowCount())
+        return UbuntuDevice::ConstPtr();
+    return m_knownDevices[index]->device();
+}
+
+UbuntuDevicesItem *UbuntuDevicesModel::createItem(UbuntuDevice::Ptr dev)
+{
+    UbuntuDevicesItem *devItem = new UbuntuDevicesItem(dev,this);
+    connect(devItem,SIGNAL(kitsChanged()),this,SLOT(kitsChanged()));
+    connect(devItem,SIGNAL(detectionStateChanged()),this,SLOT(detectionStateChanged()));
+    connect(devItem,SIGNAL(featureDetected()),this,SLOT(featureDetected()));
+    connect(devItem,SIGNAL(logUpdated()),this,SLOT(logUpdated()));
+    return devItem;
+}
+
+/*!
+ * \brief UbuntuDevicesModel::indexFromHelper
+ * Checks if the passed QObject is a DeviceHelper and returns the
+ * row index of the related device
+ */
+int UbuntuDevicesModel::indexFromHelper(QObject *possibleHelper)
+{
+    UbuntuDevicesItem* hlpr = qobject_cast<UbuntuDevicesItem*>(possibleHelper);
+    if(!hlpr) return -1;
+    return findDevice(hlpr->id().uniqueIdentifier());
+}
+
+void UbuntuDevicesModel::deviceChanged(QObject *possibleHelper, const QVector<int> &relatedRoles)
+{
+    int idx = indexFromHelper(possibleHelper);
+    if(idx < 0)
+        return;
+    QModelIndex changed = createIndex(idx,0);
+    emit dataChanged(changed,changed,relatedRoles);
+}
+
+/*!
+ * \brief UbuntuDevicesModel::readDevicesFromSettings
+ * read all known devices from the DeviceManager, this is triggered
+ * automatically on startup
+ */
+void UbuntuDevicesModel::readDevicesFromSettings()
+{
+    clear();
+
+    QList<UbuntuDevicesItem*> devs;
+    ProjectExplorer::DeviceManager* devMgr = ProjectExplorer::DeviceManager::instance();
+    for(int i = 0; i < devMgr->deviceCount(); i++) {
+        ProjectExplorer::IDevice::ConstPtr dev = devMgr->deviceAt(i);
+        if(dev && dev->type() == Core::Id(Constants::UBUNTU_DEVICE_TYPE_ID)) {
+
+            //ugly hack to get a mutable version of the device
+            //no idea why its necessary to lock it up
+            Ubuntu::Internal::UbuntuDevice* cPtr = qSharedPointerCast<const Ubuntu::Internal::UbuntuDevice>(dev)->helper()->device();
+            if(cPtr)
+                devs.append(createItem(cPtr->sharedFromThis()));
+
+        }
+    }
+
+    beginInsertRows(QModelIndex(),0,devs.count()-1);
+    m_knownDevices = devs;
+    endInsertRows();
+
+    connect(devMgr,SIGNAL(deviceAdded(Core::Id)),this,SLOT(deviceAdded(Core::Id)));
+    connect(devMgr,SIGNAL(deviceRemoved(Core::Id)),this,SLOT(deviceRemoved(Core::Id)));
+    connect(devMgr,SIGNAL(deviceUpdated(Core::Id)),this,SLOT(deviceUpdated(Core::Id)));
+}
+
+void UbuntuDevicesModel::detectionStateChanged()
+{
+    //contains the possible changed roles when this slot is called
+    static QVector<int> relatedRoles = QVector<int>()
+            << DetectionStateRole << DetectionStateStringRole;
+
+    deviceChanged(sender(),relatedRoles);
+}
+
+void UbuntuDevicesModel::featureDetected()
+{
+    //contains the possible changed roles when this slot is called
+    static QVector<int> relatedRoles = QVector<int>()
+            << DeveloperModeRole  << NetworkConnectionRole
+            << WriteableImageRole << DeveloperToolsRole;
+
+    deviceChanged(sender(),relatedRoles);
+}
+
+void UbuntuDevicesModel::logUpdated()
+{
+    //contains the possible changed roles when this slot is called
+    static QVector<int> relatedRoles = QVector<int>()
+            << LogRole;
+
+    deviceChanged(sender(),relatedRoles);
+}
+
+void UbuntuDevicesModel::kitsChanged()
+{
+    //contains the possible changed roles when this slot is called
+    static QVector<int> relatedRoles = QVector<int>()
+            << KitListRole;
+
+    deviceChanged(sender(),relatedRoles);
+}
+
+/*!
+ * \brief UbuntuDevicesModel::deviceAdded
+ * A device was added in the DeviceManager, check if know it and
+ * if we should know it. If its a new Ubuntu device its added to
+ * the known devices
+ */
+void UbuntuDevicesModel::deviceAdded(const Core::Id &id)
+{
+    ProjectExplorer::IDevice::ConstPtr ptr = ProjectExplorer::DeviceManager::instance()->find(id);
+    if(!ptr)
+        return;
+
+    if(ptr->type() != Core::Id(Constants::UBUNTU_DEVICE_TYPE_ID))
+        return;
+
+    qDebug()<<"Device Manager reports device added: "<<id.toString();
+    if (hasDevice(id.uniqueIdentifier()))
+        return;
+
+    Ubuntu::Internal::UbuntuDevice::ConstPtr ubuntuDev
+            = qSharedPointerCast<const Ubuntu::Internal::UbuntuDevice>(ptr);
+
+    Ubuntu::Internal::UbuntuDeviceHelper* hlp = ubuntuDev->helper();
+    Ubuntu::Internal::UbuntuDevice* dev = hlp->device();
+
+    beginInsertRows(QModelIndex(),rowCount(),rowCount());
+    m_knownDevices.append(createItem(dev->sharedFromThis()));
+    endInsertRows();
+}
+
+/*!
+ * \brief UbuntuDevicesWidget::deviceRemoved
+ * A device was removed from the device manager, if its one of ours
+ * we will also remove it
+ */
+void UbuntuDevicesModel::deviceRemoved(const Core::Id &id)
+{
+    int index = findDevice(id.uniqueIdentifier());
+    if(index < 0)
+        return;
+
+    qDebug()<<"Device Manager reports device removed: "<<id.toString();
+    beginRemoveRows(QModelIndex(),index,index);
+    delete m_knownDevices.takeAt(index);
+    endRemoveRows();
+}
+
+/*!
+ * \brief UbuntuDevicesModel::deviceUpdated
+ * called when a device state is changed between connected
+ * and disconnected or device data was changed
+ */
+void UbuntuDevicesModel::deviceUpdated(const Core::Id &id)
+{
+    //contains the possible changed roles when this slot is called
+    static QVector<int> relatedRoles = QVector<int>()
+            << Qt::DisplayRole << Qt::EditRole
+            << ConnectionStateRole << ConnectionStateStringRole;
+
+    int index = findDevice(id.uniqueIdentifier());
+    if(index >= 0) {
+        QModelIndex changed = createIndex(index,0);
+        emit dataChanged(changed, changed,relatedRoles);
+    }
+}
+
+void UbuntuDevicesModel::deviceConnected(const QString &id)
+{
+    int idx = findDevice(Core::Id::fromSetting(id).uniqueIdentifier());
+    if(idx >= 0)
+        return;
+
+    refresh();
+}
+
+void UbuntuDevicesModel::refreshFinished(int exitCode)
+{
+    readDevicesFromSettings();
+    foreach(UbuntuDevicesItem* item, m_knownDevices)
+        item->device()->helper()->refresh();
+
+    if(exitCode != 0) {
+        return;
+    }
+
+    //read all data from the process
+    adbReadyRead();
+
+    QStringList lines = m_adbReply.trimmed().split(QLatin1String(Constants::LINEFEED));
+    foreach(QString line, lines) {
+        line = line.trimmed();
+
+        if (line.isEmpty()) {
+            continue;
+        }
+
+        QRegularExpression exp(QLatin1String(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_ADB_REGEX));
+        QRegularExpressionMatch match = exp.match(line);
+
+        if(match.hasMatch()) {
+            QStringList lineData = match.capturedTexts();
+
+            //The first entry is always the full match
+            //which means in our case its the complete string
+            lineData.takeFirst();
+
+            if (lineData.count() == 2) {
+                QString sSerialNumber = lineData.takeFirst();
+                QString sDeviceInfo = lineData.takeFirst();
+
+                //sometimes the adb server is not started when adb devices is
+                //executed, we just skip those lines
+                if(sSerialNumber == QLatin1String("*"))
+                    continue;
+
+                if(sSerialNumber.isEmpty() || sSerialNumber.startsWith(QLatin1String(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_ADB_NOACCESS))) {
+                    continue;
+                }
+
+                registerNewDevice(sSerialNumber,sDeviceInfo);
+            }
+        }
+    }
+}
+
+void UbuntuDevicesModel::adbReadyRead()
+{
+    QString stderr = QString::fromLocal8Bit(m_adbProcess->readAllStandardError());
+    QString stdout = QString::fromLocal8Bit(m_adbProcess->readAllStandardOutput());
+
+    if(!stderr.trimmed().isEmpty()) {
+        emit stdErrMessage(stderr);
+        m_adbReply.append(stderr);
+    }
+
+    if(!stdout.trimmed().isEmpty()) {
+        emit stdOutMessage(stdout);
+        m_adbReply.append(stdout);
+    }
+    qDebug()<<m_adbReply;
+}
+
+/*!
+ * \brief UbuntuDevicesModel::registerNewDevice
+ * Registers a new device in the device manager if its not
+ * already in the known devices map.
+ * \note will not add it into model list, this
+ *       will happen automatically when the device is
+ *       registered in the device manager
+ */
+void UbuntuDevicesModel::registerNewDevice(const QString &serial, const QString &deviceInfo)
+{
+    if(findDevice(Core::Id::fromSetting(serial).uniqueIdentifier()) >= 0)
+        return;
+
+    bool isEmu = serial.startsWith(QLatin1String("emulator"));
+
+    Ubuntu::Internal::UbuntuDevice::Ptr dev = Ubuntu::Internal::UbuntuDevice::create(
+                tr("Ubuntu Device")
+                , serial
+                , isEmu ? ProjectExplorer::IDevice::Emulator : ProjectExplorer::IDevice::Hardware
+                          , ProjectExplorer::IDevice::AutoDetected);
+
+    dev->setDeviceInfoString(deviceInfo);
+    ProjectExplorer::DeviceManager::instance()->addDevice(dev);
+}
+
+/*!
+ * \class UbuntuDevicesItem
+ * Represents a Device inside the UbuntuDevicesModel,
+ * the item tracks changes in the device and notifies the model
+ * accordingly
+ */
+UbuntuDevicesItem::UbuntuDevicesItem(UbuntuDevice::Ptr device, QObject* parent) :
+    QObject(parent),
+    m_device(device)
+{
+    QList<ProjectExplorer::Kit*> allkits = ProjectExplorer::KitManager::kits();
+    foreach (ProjectExplorer::Kit* k, allkits) {
+        if( ProjectExplorer::DeviceKitInformation::deviceId(k) == device->id() )
+            m_myKits.insert(k->id());
+    }
+
+    connect(ProjectExplorer::KitManager::instance(),SIGNAL(kitAdded(ProjectExplorer::Kit*)),
+            this,SLOT(onKitAdded(ProjectExplorer::Kit*)));
+    connect(ProjectExplorer::KitManager::instance(),SIGNAL(kitRemoved(ProjectExplorer::Kit*)),
+            this,SLOT(onKitRemoved(ProjectExplorer::Kit*)));
+    connect(ProjectExplorer::KitManager::instance(),SIGNAL(kitUpdated(ProjectExplorer::Kit*)),
+            this,SLOT(onKitUpdated(ProjectExplorer::Kit*)));
+
+    connect(device->helper(),SIGNAL(detectionStateChanged()),this,SLOT(deviceStateChanged()));
+    connect(device->helper(),SIGNAL(featureDetected()),this,SIGNAL(featureDetected()));
+    connect(device->helper(),SIGNAL(message(QString)),this,SIGNAL(logUpdated()));
+}
+
+/*!
+ * \brief UbuntuDevicesItem::id
+ * Returns the internal device ID
+ */
+Core::Id UbuntuDevicesItem::id() const
+{
+    return m_device->id();
+}
+
+UbuntuDevice::Ptr UbuntuDevicesItem::device() const
+{
+    return m_device;
+}
+
+QVariantList UbuntuDevicesItem::kits() const
+{
+    QVariantList kits;
+    foreach (const Core::Id &id, m_myKits) {
+        ProjectExplorer::Kit* k = ProjectExplorer::KitManager::find(id);
+        if(!k)
+            continue;
+
+        qDebug()<<"Adding "<<k->displayName();
+
+        QVariantMap m;
+        m.insert(QStringLiteral("displayName"),k->displayName());
+        m.insert(QStringLiteral("id"),k->id().toSetting());
+        kits.append(QVariant::fromValue(m));
+    }
+
+    return kits;
+}
+
+/*!
+ * \brief UbuntuDevicesItem::onKitAdded
+ * Checks if the new Kit that just got added to the KitManager contains
+ * the device, if it does the Kit is added to the internal Kit list
+ */
+void UbuntuDevicesItem::onKitAdded(ProjectExplorer::Kit *k)
+{
+    if( ProjectExplorer::DeviceKitInformation::deviceId(k) == m_device->id() ) {
+        if(!m_myKits.contains(k->id())){
+            m_myKits.insert(k->id());
+            emit kitsChanged();
+        }
+    }
+}
+
+/*!
+ * \brief UbuntuDevicesItem::onKitRemoved
+ * Checks if the removed Kit \a k is in the internal Kit list
+ * and removes it
+ */
+void UbuntuDevicesItem::onKitRemoved(ProjectExplorer::Kit *k)
+{
+    if(m_myKits.contains(k->id())) {
+        m_myKits.remove(k->id());
+        emit kitsChanged();
+    }
+}
+
+/*!
+ * \brief UbuntuDevicesItem::onKitUpdated
+ * Checks if the updated Kit now contains the internal device
+ * or if it does NOT contain the device anymore
+ */
+void UbuntuDevicesItem::onKitUpdated(ProjectExplorer::Kit *k)
+{
+    if( ProjectExplorer::DeviceKitInformation::deviceId(k) == m_device->id() ) {
+        onKitAdded(k);
+    } else {
+        onKitRemoved(k);
+    }
+}
+
+void UbuntuDevicesItem::deviceStateChanged()
+{
+    emit detectionStateChanged();
+}
+
+}
+}
+
 
=== added file 'src/ubuntu/ubuntudevicesmodel.h'
--- src/ubuntu/ubuntudevicesmodel.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntudevicesmodel.h	2014-04-27 13:29:17 +0000
@@ -0,0 +1,169 @@
+#ifndef UBUNTUDEVICESMODEL_H
+#define UBUNTUDEVICESMODEL_H
+
+#include "ubuntudevice.h"
+#include "ubuntudevicenotifier.h"
+
+#include <coreplugin/id.h>
+
+#include <QAbstractListModel>
+#include <QList>
+
+namespace ProjectExplorer {
+class Kit;
+}
+
+namespace Ubuntu {
+namespace Internal {
+
+class UbuntuDevicesItem;
+
+class UbuntuDevicesModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+
+    enum Roles {
+        ConnectionStateRole = Qt::UserRole,
+        UniqueIdRole,
+        ConnectionStateStringRole,
+        DetectionStateRole,
+        DetectionStateStringRole,
+        KitListRole,
+        DeveloperModeRole,
+        NetworkConnectionRole,
+        WriteableImageRole,
+        DeveloperToolsRole,
+        EmulatorRole,
+        LogRole,
+        SerialIdRole,
+        ModelInfoRole,
+        DeviceInfoRole,
+        ProductInfoRole
+    };
+
+    explicit UbuntuDevicesModel(QObject *parent = 0);
+
+    Q_INVOKABLE bool set(int index, const QString &role, const QVariant &value);
+
+    int findDevice(int uniqueIdentifier) const;
+    bool hasDevice (int uniqueIdentifier) const;
+    UbuntuDevice::ConstPtr device ( const int index );
+
+    // QAbstractItemModel interface
+    virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    virtual bool setData(const QModelIndex &index, const QVariant &value, int role);
+    virtual QVariant data(const QModelIndex &index, int role) const;
+    virtual QHash<int, QByteArray> roleNames() const;
+    virtual Qt::ItemFlags flags(const QModelIndex &index) const;
+signals:
+    void logMessage (const QString &str);
+    void stdOutMessage (const QString &str);
+    void stdErrMessage (const QString &str);
+
+public slots:
+    void triggerCloneTimeConfig ( const int devId );
+    void triggerPortForwarding  ( const int devId );
+    void triggerSSHSetup        ( const int devId );
+    void triggerSSHConnection   ( const int devId );
+    void triggerReboot          ( const int devId );
+    void triggerRebootBootloader( const int devId );
+    void triggerRebootRecovery  ( const int devId );
+    void triggerShutdown        ( const int devId );
+    void triggerKitAutocreate   ( const int devId );
+    void triggerKitRemove       (const int devId, const QVariant &kitid );
+    void refresh                ();
+
+protected:
+    void clear ();
+    UbuntuDevicesItem *createItem (UbuntuDevice::Ptr dev);
+    int indexFromHelper (QObject* possibleHelper);
+    void deviceChanged(QObject* possibleHelper, const QVector<int> &relatedRoles);    
+    void registerNewDevice(const QString &serial, const QString &deviceInfo);
+
+protected slots:
+    void readDevicesFromSettings();
+    void detectionStateChanged ();
+    void featureDetected ();
+    void logUpdated ();
+    void kitsChanged ();
+    void deviceAdded(const Core::Id &id);
+    void deviceRemoved(const Core::Id &id);
+    void deviceUpdated(const Core::Id &id);
+    void deviceConnected(const QString&id);
+    void refreshFinished(int exitCode);
+    void adbReadyRead();
+
+private:
+     QList<UbuntuDevicesItem*> m_knownDevices;
+     UbuntuDeviceNotifier *m_deviceNotifier;
+     QProcess *m_adbProcess;
+     QString   m_adbReply;
+};
+
+/*!
+ * \brief The UbuntuDeviceStates class
+ * Provides enums for QML
+ */
+class UbuntuDeviceStates : public QObject
+{
+    Q_OBJECT
+public:
+    enum FeatureState {
+        NotAvailable = UbuntuDevice::NotAvailable,
+        Unknown = UbuntuDevice::Unknown,
+        Available = UbuntuDevice::Available
+    };
+    Q_ENUMS(FeatureState)
+
+    enum DeviceDetectionState {
+        NotStarted = UbuntuDevice::NotStarted,
+        Detecting,
+        Done = UbuntuDevice::Done
+    };
+    Q_ENUMS(DeviceDetectionState)
+
+    enum DeviceConnectionState {
+        DeviceReadyToUse    = ProjectExplorer::IDevice::DeviceReadyToUse,
+        DeviceConnected     = ProjectExplorer::IDevice::DeviceConnected,
+        DeviceDisconnected  = ProjectExplorer::IDevice::DeviceDisconnected,
+        DeviceStateUnknown  = ProjectExplorer::IDevice::DeviceStateUnknown
+    };
+    Q_ENUMS(DeviceConnectionState)
+};
+
+class UbuntuDevicesItem : public QObject
+{
+    Q_OBJECT
+public:
+    UbuntuDevicesItem(Ubuntu::Internal::UbuntuDevice::Ptr device, QObject* parent = 0);
+
+    Core::Id id() const;
+    UbuntuDevice::Ptr device() const;
+    QVariantList kits() const;
+
+signals:
+    void kitsChanged ();
+    void connectionChanged ();
+    void detectionStateChanged ();
+    void featureDetected ();
+    void logUpdated();
+
+private slots:
+    void onKitAdded(ProjectExplorer::Kit *k);
+    void onKitRemoved(ProjectExplorer::Kit *k);
+    void onKitUpdated(ProjectExplorer::Kit *k);
+    void deviceStateChanged ();
+
+
+private:
+    Ubuntu::Internal::UbuntuDevice::Ptr m_device;
+    QSet<Core::Id> m_myKits;
+};
+
+}
+}
+
+
+
+#endif // UBUNTUDEVICESMODEL_H
 
=== added file 'src/ubuntu/ubuntuemulatormodel.cpp'
--- src/ubuntu/ubuntuemulatormodel.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntuemulatormodel.cpp	2014-04-27 13:29:17 +0000
@@ -0,0 +1,408 @@
+#include "ubuntuemulatormodel.h"
+#include "ubuntuconstants.h"
+
+#include <utils/projectnamevalidatinglineedit.h>
+
+#include <QMutableStringListIterator>
+#include <QCoreApplication>
+#include <QStandardPaths>
+#include <QDir>
+#include <QRegularExpression>
+#include <QRegularExpressionMatch>
+
+namespace Ubuntu {
+namespace Internal {
+
+/*!
+  \brief UbuntuEmulatorModel
+  Provides informations about all existing emulators
+  \note This will be merged with the devices model when the
+        emulator tool can query the serial number of not running
+        emulators
+ */
+
+UbuntuEmulatorModel::UbuntuEmulatorModel(QObject *parent) :
+    QAbstractListModel(parent) ,
+    m_process(0),
+    m_emulatorInstalled(false) ,
+    m_state(UbuntuEmulatorModel::Initial),
+    m_cancellable(false)
+{
+    m_process = new UbuntuProcess(this);
+    connect(m_process,SIGNAL(message(QString)),this,SLOT(onMessage(QString)));
+    connect(m_process,SIGNAL(finished(QString,int)),this,SLOT(processFinished(QString,int)));
+    connect(m_process,SIGNAL(stdOut(QString)),this,SIGNAL(stdOutMessage(QString)));
+    connect(m_process,SIGNAL(error(QString)),this,SIGNAL(stdErrMessage(QString)));
+
+    checkEmulatorInstalled();
+}
+
+bool UbuntuEmulatorModel::emulatorInstalled() const
+{
+    return m_emulatorInstalled;
+}
+
+void UbuntuEmulatorModel::setEmulatorInstalled(bool arg)
+{
+    if (m_emulatorInstalled != arg) {
+        m_emulatorInstalled = arg;
+        emit emulatorInstalledChanged(arg);
+    }
+}
+
+bool UbuntuEmulatorModel::busy() const
+{
+    return m_busy;
+}
+
+void UbuntuEmulatorModel::setBusy(bool arg)
+{
+    if (m_busy != arg) {
+        m_busy = arg;
+        emit busyChanged(arg);
+    }
+}
+
+QString UbuntuEmulatorModel::state() const
+{
+    switch(m_state) {
+        case CheckEmulator: {
+            return tr("Checking if emulator tool is installed");
+            break;
+        }
+        case InstallEmulator: {
+            return tr("Installing emulator tool");
+            break;
+        }
+        case CreateEmulatorImage: {
+            return tr("Creating emulator image");
+            break;
+        }
+        case FindImages: {
+            return tr("Searching for emulator images");
+            break;
+        }
+        default:
+            return QString();
+            break;
+    }
+}
+
+void UbuntuEmulatorModel::setState(UbuntuEmulatorModel::State newState)
+{
+    if(m_state != newState) {
+        m_state = newState;
+        if(m_state == UbuntuEmulatorModel::Initial || m_state == UbuntuEmulatorModel::Idle)
+            setBusy(false);
+        else
+            setBusy(true);
+
+        emit stateChanged(state());
+    }
+}
+
+bool UbuntuEmulatorModel::cancellable() const
+{
+    return m_cancellable;
+}
+
+void UbuntuEmulatorModel::setCancellable(bool arg)
+{
+    if (m_cancellable != arg) {
+        m_cancellable = arg;
+        emit cancellableChanged(arg);
+    }
+}
+
+void UbuntuEmulatorModel::beginAction(const QString &msg)
+{
+    emit logMessage(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_ACTION_BEGIN).arg(msg));
+}
+
+void UbuntuEmulatorModel::endAction(const QString &msg)
+{
+    emit logMessage(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_ACTION_END).arg(msg));
+}
+
+int UbuntuEmulatorModel::rowCount(const QModelIndex &parent) const
+{
+    if(parent.isValid())
+        return 0;
+    return m_data.size();
+}
+
+QVariant UbuntuEmulatorModel::data(const QModelIndex &index, int role) const
+{
+    if(!index.isValid()
+            || index.parent().isValid()
+            || index.row() < 0
+            || index.row() > rowCount())
+        return QVariant();
+
+    switch (role) {
+        case Qt::DisplayRole:
+        case Qt::EditRole:
+            return m_data[index.row()].name;
+        case UbuntuVersionRole:
+            return m_data[index.row()].ubuntuVersion;
+        case DeviceVersionRole:
+            return m_data[index.row()].deviceVersion;
+        case ImageVersionRole:
+            return m_data[index.row()].imageVersion;
+        default:
+            break;
+    }
+    return QVariant();
+}
+
+QHash<int, QByteArray> UbuntuEmulatorModel::roleNames() const
+{
+    QHash<int, QByteArray> rNames = QAbstractListModel::roleNames();
+    rNames.insert(UbuntuVersionRole,"ubuntuVersion");
+    rNames.insert(DeviceVersionRole,"deviceVersion");
+    rNames.insert(ImageVersionRole,"imageVersion");
+    return rNames;
+}
+
+Qt::ItemFlags UbuntuEmulatorModel::flags(const QModelIndex &index) const
+{
+    return QAbstractListModel::flags(index);
+}
+
+void UbuntuEmulatorModel::clear()
+{
+    if(rowCount()) {
+        beginResetModel();
+        m_data.clear();
+        endResetModel();
+    }
+}
+
+void UbuntuEmulatorModel::checkEmulatorInstalled()
+{
+    setState(CheckEmulator);
+    setCancellable(false);
+
+    beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_EMULATOR_INSTALLED));
+    m_process->stop();
+    QString sEmulatorPackageName = QLatin1String(Ubuntu::Constants::EMULATOR_PACKAGE_NAME);
+    m_process->append(QStringList()
+                      << QString::fromLatin1(Constants::UBUNTUWIDGETS_LOCAL_PACKAGE_INSTALLED_SCRIPT).arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH).arg(sEmulatorPackageName)
+                      << QCoreApplication::applicationDirPath());
+    m_process->start(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_EMULATOR_INSTALLED));
+
+}
+
+void UbuntuEmulatorModel::findEmulatorImages()
+{
+    setState(FindImages);
+    setCancellable(false);
+
+    beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_SEARCH_IMAGES));
+    m_process->stop();
+    m_process->append(QStringList()
+                      << QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_SEARCH_IMAGES_SCRIPT).arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH)
+                      << QCoreApplication::applicationDirPath());
+    m_process->start(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_SEARCH_IMAGES));
+}
+
+void UbuntuEmulatorModel::installEmulator()
+{
+    if(m_emulatorInstalled)
+        return;
+
+    setState(InstallEmulator);
+    setCancellable(false);
+
+    beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_INSTALL_EMULATOR_PACKAGE));
+    QString sEmulatorPackageName = QLatin1String(Ubuntu::Constants::EMULATOR_PACKAGE_NAME);
+    m_process->stop();
+    m_process->append(QStringList()
+                      << QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_INSTALL_EMULATOR_PACKAGE_SCRIPT).arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH).arg(sEmulatorPackageName)
+                      << QCoreApplication::applicationDirPath());
+    m_process->start(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_INSTALL_EMULATOR_PACKAGE));
+}
+
+void UbuntuEmulatorModel::createEmulatorImage(const QString &name)
+{
+    setState(CreateEmulatorImage);
+    setCancellable(true);
+
+    beginAction(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR));
+    m_process->stop();
+    QString strEmulatorName = name;
+    QString strEmulatorPath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
+    strEmulatorPath += QDir::separator();
+    strEmulatorPath += QLatin1String(Constants::DEFAULT_EMULATOR_PATH);
+    strEmulatorPath += QDir::separator();
+    m_process->append(QStringList()
+                      << QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR_SCRIPT)
+                         .arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH).arg(strEmulatorPath).arg(strEmulatorName)
+                      << QCoreApplication::applicationDirPath());
+    m_process->start(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_CREATE_EMULATOR));
+}
+
+void UbuntuEmulatorModel::startEmulator(const QString &name)
+{
+    QStringList args = QStringList() << name;
+    QProcess::startDetached(QString::fromLatin1(Constants::UBUNTUDEVICESWIDGET_LOCAL_START_EMULATOR_SCRIPT).arg(Ubuntu::Constants::UBUNTU_SCRIPTPATH)
+                            ,args
+                            ,QCoreApplication::applicationDirPath());
+}
+
+QVariant UbuntuEmulatorModel::validateEmulatorName(const QString &name)
+{
+
+    QString error;
+    bool result = Utils::ProjectNameValidatingLineEdit::validateProjectName(name,&error);
+
+    if(result) {
+        foreach(const EmulatorItem &item, m_data){
+            if(item.name == name) {
+                result = false;
+                error  = tr("Emulator name already exists");
+            }
+        }
+    }
+
+    QVariantMap m;
+    m.insert(QStringLiteral("valid"),result);
+    m.insert(QStringLiteral("error"),error);
+    return QVariant::fromValue(m);
+}
+
+void UbuntuEmulatorModel::cancel()
+{
+    if (m_cancellable && m_state == CreateEmulatorImage) {
+        m_process->stop();
+    }
+}
+
+void UbuntuEmulatorModel::onMessage(const QString &msg)
+{
+    if (msg.startsWith(QLatin1String(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_UNABLE_TO_FETCH))) {
+        setEmulatorInstalled(false);
+    }
+    m_reply.append(msg);
+}
+
+void UbuntuEmulatorModel::processFinished(const QString &, int)
+{
+    State lastState = m_state;
+    setCancellable(false);
+
+    setState(UbuntuEmulatorModel::Idle);
+    switch(lastState) {
+        case CheckEmulator: {
+            QStringList lines = m_reply.trimmed().split(QLatin1String(Constants::LINEFEED));
+            foreach(QString line, lines) {
+                line = line.trimmed();
+                if (line.isEmpty()) {
+                    continue;
+                }
+                if (line.startsWith(QLatin1String(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_LOCAL_NO_EMULATOR_INSTALLED))) {
+                    setEmulatorInstalled(false);
+                } else {
+                    QStringList lineData = line.split(QLatin1String(Constants::SPACE));
+                    QString sEmulatorPackageStatus = lineData.takeFirst();
+                    //QString sEmulatorPackageName = lineData.takeFirst();
+                    //QString sEmulatorPackageVersion = lineData.takeFirst();
+                    if (sEmulatorPackageStatus.startsWith(QLatin1String(Constants::INSTALLED))) {
+                        setEmulatorInstalled(true);
+                        findEmulatorImages();
+                    }
+                }
+            }
+            break;
+        }
+        case InstallEmulator: {
+            QStringList lines = m_reply.trimmed().split(QLatin1String(Constants::LINEFEED));
+            foreach(QString line, lines) {
+                line = line.trimmed();
+                if (line.isEmpty()) {
+                    continue;
+                }
+                if (line.startsWith(QLatin1String(Constants::UBUNTUDEVICESWIDGET_ONFINISHED_LOCAL_NO_EMULATOR_INSTALLED))) {
+                    setEmulatorInstalled(false);
+                    break;
+                } else {
+                    QStringList lineData = line.split(QLatin1String(Constants::SPACE));
+                    QString sEmulatorPackageStatus = lineData.takeFirst();
+                    //QString sEmulatorPackageName = lineData.takeFirst();
+                    //QString sEmulatorPackageVersion = lineData.takeFirst();
+                    if (sEmulatorPackageStatus.startsWith(QLatin1String(Constants::INSTALLED))) {
+                        setEmulatorInstalled(true);
+                        findEmulatorImages();
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+        case CreateEmulatorImage: {
+            findEmulatorImages();
+            break;
+        }
+        case FindImages: {
+            QStringList lines = m_reply.trimmed().split(QLatin1String(Constants::LINEFEED));
+            clear();
+
+            QList<EmulatorItem> items;
+
+            QMutableStringListIterator iter(lines);
+            QRegularExpression regexName   (QStringLiteral("^(\\w+)"));
+            QRegularExpression regexUbuntu (QStringLiteral("ubuntu=([0-9]+)"));
+            QRegularExpression regexDevice (QStringLiteral("device=([0-9]+)"));
+            QRegularExpression regexVersion(QStringLiteral("version=([0-9]+)"));
+            while (iter.hasNext()) {
+                QString line = iter.next();
+                if(line.isEmpty()) {
+                    iter.remove();
+                    continue;
+                }
+
+                qDebug()<<"Handling emulator: "<<line;
+                QRegularExpressionMatch mName = regexName.match(line);
+                QRegularExpressionMatch mUbu  = regexUbuntu.match(line);
+                QRegularExpressionMatch mDev  = regexDevice.match(line);
+                QRegularExpressionMatch mVer  = regexVersion.match(line);
+
+                if(!mName.hasMatch())
+                    continue;
+
+                EmulatorItem item;
+                item.name = mName.captured(1);
+
+                if(mUbu.hasMatch())
+                    item.ubuntuVersion = mUbu.captured(1);
+                else
+                    item.ubuntuVersion = tr("unknown");
+
+                if(mDev.hasMatch())
+                    item.deviceVersion = mDev.captured(1);
+                else
+                    item.deviceVersion = tr("unknown");
+
+                if(mVer.hasMatch())
+                    item.imageVersion = mVer.captured(1);
+                else
+                    item.imageVersion = tr("unknown");
+
+                items.append(item);
+            }
+
+            if(items.count()) {
+                beginResetModel();
+                m_data = items;
+                endResetModel();
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    m_reply.clear();
+}
+
+} // namespace Internal
+} // namespace Ubuntu
 
=== added file 'src/ubuntu/ubuntuemulatormodel.h'
--- src/ubuntu/ubuntuemulatormodel.h	1970-01-01 00:00:00 +0000
+++ src/ubuntu/ubuntuemulatormodel.h	2014-04-27 13:29:17 +0000
@@ -0,0 +1,102 @@
+#ifndef UBUNTU_INTERNAL_UBUNTUEMULATORMODEL_H
+#define UBUNTU_INTERNAL_UBUNTUEMULATORMODEL_H
+
+#include "ubuntuprocess.h"
+#include <QAbstractListModel>
+
+namespace Ubuntu {
+namespace Internal {
+
+class UbuntuEmulatorModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+
+    enum State {
+        Initial,
+        CheckEmulator,
+        InstallEmulator,
+        CreateEmulatorImage,
+        FindImages,
+        Idle
+    };
+
+    enum Roles {
+        UbuntuVersionRole = Qt::UserRole,
+        DeviceVersionRole,
+        ImageVersionRole
+    };
+
+    struct EmulatorItem {
+        QString name;
+        QString ubuntuVersion;
+        QString deviceVersion;
+        QString imageVersion;
+    };
+
+    Q_PROPERTY(bool emulatorInstalled READ emulatorInstalled WRITE setEmulatorInstalled NOTIFY emulatorInstalledChanged)
+    Q_PROPERTY(bool busy READ busy NOTIFY busyChanged)
+    Q_PROPERTY(bool cancellable READ cancellable NOTIFY cancellableChanged)
+    Q_PROPERTY(QString state READ state NOTIFY stateChanged)
+
+    explicit UbuntuEmulatorModel(QObject *parent = 0);
+
+    void setEmulatorInstalled(bool arg);
+    bool emulatorInstalled() const;
+
+    bool busy() const;
+    QString state() const;
+    bool cancellable() const;
+
+    // QAbstractItemModel interface
+    virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    virtual QVariant data(const QModelIndex &index, int role) const;
+    virtual QHash<int, QByteArray> roleNames() const;
+    virtual Qt::ItemFlags flags(const QModelIndex &index) const;
+
+protected:
+    void clear();
+    void setBusy(bool arg);
+    void setState(State newState);
+    void beginAction (const QString &msg);
+    void endAction (const QString &msg);
+    void setCancellable(bool arg);
+
+public slots:
+    void checkEmulatorInstalled ();
+    void findEmulatorImages     ();
+    void installEmulator ();
+    void createEmulatorImage (const QString &name);
+    void startEmulator (const QString &name);
+    QVariant validateEmulatorName ( const QString &name);
+    void cancel ();
+
+protected slots:
+    void onMessage (const QString &msg);
+    void processFinished (const QString &, int);
+
+signals:
+    void emulatorInstalledChanged(bool arg);
+    void busyChanged(bool arg);
+    void stateChanged(const QString &arg);
+    void logMessage (const QString &str);
+    void stdOutMessage (const QString &str);
+    void stdErrMessage (const QString &str);
+
+    void cancellableChanged(bool arg);
+
+private:
+    QString m_reply;
+    UbuntuProcess *m_process;
+    bool m_emulatorInstalled;
+    State m_state;
+    bool m_busy;
+
+    QList<EmulatorItem> m_data;
+    bool m_cancellable;
+};
+
+} // namespace Internal
+} // namespace Ubuntu
+
+#endif // UBUNTU_INTERNAL_UBUNTUEMULATORMODEL_H
 
=== modified file 'src/ubuntu/ubuntukitmanager.cpp'
--- src/ubuntu/ubuntukitmanager.cpp	2014-04-09 15:00:21 +0000
+++ src/ubuntu/ubuntukitmanager.cpp	2014-04-27 13:29:17 +0000
@@ -23,11 +23,24 @@
     return ProjectExplorer::ToolChainKitInformation::toolChain(a) == ProjectExplorer::ToolChainKitInformation::ToolChainKitInformation::toolChain(b);
 }
 
+static bool lessThanToolchain (const ClickToolChain* left, const ClickToolChain* right)
+{
+    const UbuntuClickTool::Target &leftTarget = left->clickTarget();
+    const UbuntuClickTool::Target &rightTarget = right->clickTarget();
+
+    if(leftTarget.majorVersion < rightTarget.majorVersion)
+        return true;
+    if(leftTarget.minorVersion < rightTarget.minorVersion)
+        return true;
+
+    return false;
+}
+
 UbuntuKitManager::UbuntuKitManager()
 {
 }
 
-void UbuntuKitManager::autoDetectKits()
+QList<ClickToolChain *> UbuntuKitManager::clickToolChains()
 {
     QList<ClickToolChain *> toolchains;
     // having a empty toolchains list will remove all autodetected kits for android
@@ -41,6 +54,42 @@
             toolchains << static_cast<ClickToolChain *>(tc);
         }
     }
+    return toolchains;
+}
+
+void UbuntuKitManager::autoCreateKit(UbuntuDevice::Ptr device)
+{
+    QList<ClickToolChain*> toolchains = clickToolChains();
+    if(toolchains.size() == 0) {
+        //create target
+        return;
+    }
+
+    qSort(toolchains.begin(),toolchains.end(),lessThanToolchain);
+
+    //right now we are going to use the last toolchain, because its the one
+    //with the highest framework, this needs to be changed once we have x86 targets
+    ClickToolChain* tc = toolchains.last();
+    ProjectExplorer::Kit* newKit = createKit(tc);
+    if(newKit) {
+        fixKit(newKit);
+
+        newKit->setDisplayName(tr("%1 (GCC %2-%3-%4)")
+                            .arg(device->displayName())
+                            .arg(tc->clickTarget().architecture)
+                            .arg(tc->clickTarget().framework)
+                            .arg(tc->clickTarget().series));
+
+        ProjectExplorer::DeviceKitInformation::setDevice(newKit,device);
+        ProjectExplorer::KitManager::registerKit(newKit);
+    }
+}
+
+void UbuntuKitManager::autoDetectKits()
+{
+    // having a empty toolchains list will remove all autodetected kits for android
+    // exactly what we want in that case
+    QList<ClickToolChain *> toolchains = clickToolChains();
 
     QList<ProjectExplorer::Kit *> existingKits;
     foreach (ProjectExplorer::Kit *k, ProjectExplorer::KitManager::kits()) {
 
=== modified file 'src/ubuntu/ubuntukitmanager.h'
--- src/ubuntu/ubuntukitmanager.h	2014-04-10 10:56:24 +0000
+++ src/ubuntu/ubuntukitmanager.h	2014-04-27 13:29:17 +0000
@@ -19,6 +19,7 @@
 #define UBUNTU_INTERNAL_UBUNTUKITMANAGER_H
 
 #include "clicktoolchain.h"
+#include "ubuntudevice.h"
 #include <projectexplorer/kit.h>
 
 namespace Debugger{
@@ -34,10 +35,12 @@
 public:
     UbuntuKitManager();
 
+    static void autoCreateKit  ( UbuntuDevice::Ptr device );
     static void autoDetectKits ();
     static ProjectExplorer::Kit *createKit (ClickToolChain* tc);
     static QVariant createOrFindDebugger(const Utils::FileName &path);
     static void fixKit (ProjectExplorer::Kit* k);
+    static QList<ClickToolChain *> clickToolChains();
 };
 
 } // namespace Internal
 
=== modified file 'src/ubuntu/ubuntumenu.cpp'
--- src/ubuntu/ubuntumenu.cpp	2014-04-15 07:51:40 +0000
+++ src/ubuntu/ubuntumenu.cpp	2014-04-27 13:29:17 +0000
@@ -19,7 +19,7 @@
 #include "ubuntumenu.h"
 #include "ubuntushared.h"
 #include "ubuntuconstants.h"
-#include "ubuntudeviceswidget.h"
+#include "ubuntudevicemode.h"
 #include "ubuntuproject.h"
 #include "ubuntuclicktool.h"
 #include "ubuntudevice.h"
@@ -82,7 +82,7 @@
     connect(&m_ubuntuProcess,SIGNAL(error(QString)),this,SLOT(onError(QString)));
 
     connect(ProjectExplorer::ProjectExplorerPlugin::instance(),SIGNAL(updateRunActions()),this,SLOT(slotUpdateActions()));
-    connect(UbuntuDevicesWidget::instance(),SIGNAL(updateDeviceActions()),this,SLOT(slotUpdateActions()));
+    connect(UbuntuDeviceMode::instance(),SIGNAL(updateDeviceActions()),this,SLOT(slotUpdateActions()));
 }
 
 
@@ -103,7 +103,7 @@
 
     //bool canRun = projectExplorerInstance->canRun(startupProject,ProjectExplorer::NormalRunMode);
     bool projectOpen = (startupProject!=NULL);
-    bool deviceDetected = UbuntuDevicesWidget::instance()->deviceDetected();
+    bool deviceDetected = !UbuntuDeviceMode::instance()->device().isNull();
 
     foreach(QAction* act, m_actions) {
         bool requiresDevice = act->property(Constants::UBUNTU_MENUJSON_DEVICEREQUIRED).toBool();
@@ -475,8 +475,13 @@
                         }
                     }
 
-                    UbuntuDevice::ConstPtr device = UbuntuDevicesWidget::instance()->device();
+                    UbuntuDevice::ConstPtr device = UbuntuDeviceMode::instance()->device();
                     if (device) {
+                        if( device->deviceState() != ProjectExplorer::IDevice::DeviceReadyToUse ) {
+                            QMessageBox::warning(0,tr("Device not ready"),tr("The currently selected device is not ready, please select another one on the devices mode"));
+                            return;
+                        }
+
                         command = command.replace(QLatin1String(Constants::UBUNTU_ACTION_DEVICE_IP),device->sshParameters().host);
                         command = command.replace(QLatin1String(Constants::UBUNTU_ACTION_DEVICE_USERNAME),device->sshParameters().userName);
                         command = command.replace(QLatin1String(Constants::UBUNTU_ACTION_DEVICE_PORT),QString::number(device->sshParameters().port));
 
=== modified file 'src/ubuntu/ubuntuplugin.cpp'
--- src/ubuntu/ubuntuplugin.cpp	2014-04-10 18:50:24 +0000
+++ src/ubuntu/ubuntuplugin.cpp	2014-04-27 13:29:17 +0000
@@ -31,6 +31,7 @@
 #include "ubuntucmakebuildconfiguration.h"
 #include "ubunturemotedeployconfiguration.h"
 #include "ubuntulocaldeployconfiguration.h"
+#include "ubuntudevicesmodel.h"
 #include "localportsmanager.h"
 
 #include <coreplugin/modemanager.h>
@@ -42,6 +43,7 @@
 #include <QDebug>
 #include <QFileInfo>
 #include <QGuiApplication>
+#include <QtQml>
 
 using namespace Ubuntu;
 using namespace Ubuntu::Internal;
@@ -61,8 +63,9 @@
     Q_UNUSED(arguments)
     Q_UNUSED(errorString)
 
+    qmlRegisterUncreatableType<UbuntuDeviceStates>("Ubuntu.DevicesModel",0,1,"States",QStringLiteral("Not instantiable"));
+
     const QLatin1String mimetypesXml(Constants::UBUNTU_MIMETYPE_XML);
-
     if (!Core::MimeDatabase::addMimeTypes(mimetypesXml, errorString))
         return false;
 
 
=== modified file 'src/ubuntu/ubuntuprocess.cpp'
--- src/ubuntu/ubuntuprocess.cpp	2014-03-06 09:43:48 +0000
+++ src/ubuntu/ubuntuprocess.cpp	2014-04-27 13:29:17 +0000
@@ -122,11 +122,8 @@
         emit finished(m_currentProcess->program(), code);
         return;
     }
-    QString errorMsg = QString::fromLocal8Bit(m_currentProcess->readAllStandardError());
-    if (errorMsg.trimmed().length()>0) emit error(errorMsg);
-    QString msg = QString::fromLocal8Bit(m_currentProcess->readAllStandardOutput());
-    if (msg.trimmed().length()>0) emit message(msg);
 
+    processReadyRead();
     emit finished(m_currentProcess->program(), code);
     emit finished(m_currentProcess,m_currentProcess->program(),code);
     processCmdQueue();
@@ -135,10 +132,12 @@
 void UbuntuProcess::processReadyRead() {
     QString stderr = QString::fromLocal8Bit(m_currentProcess->readAllStandardError());
     QString stdout = QString::fromLocal8Bit(m_currentProcess->readAllStandardOutput());
-    if (!stderr.isEmpty()) {
+    if (!stderr.trimmed().isEmpty()) {
+        emit error(stderr);
         emit message(stderr);
     }
-    if (!stdout.isEmpty()) {
+    if (!stdout.trimmed().isEmpty()) {
+        emit stdOut(stdout);
         emit message(stdout);
     }
 }
 
=== modified file 'src/ubuntu/ubuntuprocess.h'
--- src/ubuntu/ubuntuprocess.h	2014-03-06 09:43:48 +0000
+++ src/ubuntu/ubuntuprocess.h	2014-04-27 13:29:17 +0000
@@ -45,8 +45,9 @@
     void start(QString taskTitle);
 
 signals:
-    void message(QString);
-    void error(QString);
+    void message(const QString&);
+    void error (const QString&);
+    void stdOut(const QString&);
     void finished(QString,int);
     void finished(const QProcess*,QString,int);
     void started(QString);
 
=== modified file 'src/ubuntu/ubunturemoterunconfiguration.cpp'
--- src/ubuntu/ubunturemoterunconfiguration.cpp	2014-04-10 11:04:55 +0000
+++ src/ubuntu/ubunturemoterunconfiguration.cpp	2014-04-27 13:29:17 +0000
@@ -95,6 +95,8 @@
         env.appendOrSet(QLatin1String("QML2_IMPORT_PATH"),
                         QString::fromLatin1("lib/%1").arg(clickTc->gnutriplet()),
                         QString::fromLatin1(":"));
+        env.prependOrSetPath(QStringLiteral("lib/")+clickTc->gnutriplet()+QStringLiteral("/bin"));
+        env.appendOrSetPath(QStringLiteral("$PATH"));
     }
     env.appendOrSet(QLatin1String("pkgdir"),workingDirectory());
     env.appendOrSet(QLatin1String("APP_ID"),m_appId);
@@ -199,16 +201,24 @@
         return false;
     } else {
         //looks like a application without a launcher
-        m_localExecutable = target()->activeBuildConfiguration()->buildDirectory().toString()
-                + QDir::separator()
-                + QLatin1String(Constants::UBUNTU_DEPLOY_DESTDIR)
-                + QDir::separator()
-                + command;
-
-        m_remoteExecutable = workingDirectory()
-                + QDir::separator()
-                + command;
-
+        CMakeProjectManager::CMakeProject* pro = static_cast<CMakeProjectManager::CMakeProject*> (target()->project());
+        foreach(const CMakeProjectManager::CMakeBuildTarget &t, pro->buildTargets()) {
+            if(t.library || t.executable.isEmpty())
+                continue;
+
+            QFileInfo execInfo(t.executable);
+
+            if(execInfo.fileName() == commInfo.fileName())
+                m_localExecutable = t.executable;
+        }
+
+        if (m_localExecutable.isEmpty()) {
+            if(errorMessage)
+                *errorMessage = tr("Could not find %1 in the project targets").arg(command);
+            return false;
+        }
+
+        m_remoteExecutable = command;
     }
 
     QFileInfo desk(m_desktopFile);
 
=== modified file 'src/ubuntu/ubuntusettingsdeviceconnectivitywidget.cpp'
--- src/ubuntu/ubuntusettingsdeviceconnectivitywidget.cpp	2014-04-10 12:29:54 +0000
+++ src/ubuntu/ubuntusettingsdeviceconnectivitywidget.cpp	2014-04-27 13:29:17 +0000
@@ -18,7 +18,6 @@
 
 #include "ubuntusettingsdeviceconnectivitywidget.h"
 #include "ui_ubuntusettingsdeviceconnectivitywidget.h"
-#include "ubuntudeviceswidget.h"
 #include "ubuntuconstants.h"
 
 using namespace Ubuntu;