Merge lp:~cyphermox/ubuntu-system-settings/bluetooth-redesign into lp:ubuntu-system-settings

[Mathieu Trudel-Lapierre]

Bluetooth UI redesign

* Bluetooth UI redesign:
  - Redesign the UI to follow the specification.
  - Create devices only when attempting to connect.
  - Bugfixes for displaying icons for devices.
  - Show new icons for common device types.
  - Support more device types.
  - Show Trusted (known) devices in a separate list from the devices detected
    by Discovery.
  - Allow for a way to forget (unpair) a known device. (LP: #1336197)
  - Follow the state of the Bluetooth adapter for whether Bluetooth
    is enabled. (LP: #1272317)
  - Miscellaneous bug fixes.

[Charles Kerr (charlesk)]

Mostly looks very good, I like the way interfaces are handled now.

It would be good for someone better at QML to look over the UI, but I've added a handful of comments below for the C++ code.

[Mathieu Trudel-Lapierre (cyphermox)]

Thanks for the review!

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:807
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1024/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2202/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/1838/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/216/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/216/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/216/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3375/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2056/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1024/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:809
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1025/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2207
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/1841
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/217
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/217
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/217/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/217
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-mako/2417
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3381
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3381/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/10095
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-utopic/1545
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2060
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2060/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1025/rebuild

review: Needs Fixing (continuous-integration)

[Brendan Donegan (brendan-donegan)]

We should really have some tests for this - it's a pretty big update to this feature.

review: Needs Fixing

[Mathieu Trudel-Lapierre (cyphermox)]

Tests are quite difficult to do for this, given that the system needs remote devices.

I'm however already reviewing/updating the manual testing doc.

[Brendan Donegan (brendan-donegan)]

I understand comprehensive testing might be difficult, but is there anything you could achieve by mocking, or otherwise?

[Iain Lane (laney)]

AIUI this is all going through the bluez D-Bus API — you should be able to mock this (dbusmock has a bluez 4 template that might be a good starting point for a bluez 4 one).

Will try to review this week assuming nobody beats me to it. In the meantime, please wrap all lines at 80 chars. :)

[Sebastien Bacher (seb128)]

Thanks, some comments from testing on my laptop config and looking to the UI side

* those are displayed on start
 WARNING - qrc:/qml/EntryComponent.qml:39:9: StatusIcon is not a type

* it hangs for 10 seconds before displaying the u.i, could be due to those
" WARNING - Could not initiate service discovery: "Host is down""

(the service not being available should not block the loading)

* that seems another valid issue
"bluetooth/PageComponent.qml:50:17 depends on non-NOTIFYable properties: Bluetooth::agent"

* looking to https://wiki.ubuntu.com/Bluetooth#phone

- there should be no separator following the discoverable/not discoverable entry
- when a device is connected there is a vertical separator on the left of the arrow on the right side, that's not on the device (and it should be a standard item that doesn't do that?)
- the "none detected" label oscillate between disabled/enable color, is that wanted?

* in the details device-settings subscreen
- the items have their text horizontally centered on the design
- they don't have separators
- the connect automatically should be a checkbox, not a switch
- connect automatically seems always checked when the devices are not auto connected

* is it supposed to be able to pair/ask for a pin password to connect to e.g a phone device?

review: Needs Fixing

[Mathieu Trudel-Lapierre (cyphermox)]

I have filed bugs for the issues I will not be addressing right away; which are either already present or currently complicated to address as they would require updated UI components (or discussion with design):

 bug 1346492 [bluetooth] on Device details subscreen: there should be no separators between data items
 bug 1346488 [bluetooth] on Device details subscreen: text should be centered
 bug 1346486 [bluetooth] there should be no vertical separator next to the progression on Connected devices
 bug 1346484 [bluetooth] there should be no separator following the discoverable/not discoverable entry
 bug 1346483 [bluetooth] bluetooth/PageComponent.qml:50:17 depends on non-NOTIFYable properties: Bluetooth::agent

[Sebastien Bacher (seb128)]

Thanks for opening those bugs.

If we land the work with known issue it would be nice to have somebody commiting to work on those, though it feels like some are trivial changes (like having no separator is a property to set to false on the listitems and that it would be easier to add the line that to deal with bug reports)

Some of the other issues still need to be addressed though (the 10 seconds delay at opening, the type warnings, the wrong widget, the fact that devices are marked as autoconnected by default when they don't do that)

[Brendan Donegan (brendan-donegan)]

Mathieu, what is the plan for testing this then? Will you be able to have a look at the dbus-mock template Laney mentioned?

[Mathieu Trudel-Lapierre (cyphermox)]

What is the property for the separators? I have looked and have been unable to find this in documentation.

As for the delay and some of the warnings; I have addressed those in the last few commits.

Do note that the warning about the agent property was already present and is cosmetic; it doesn't seem to affect the behavior of the program in any meaningful way; and the EntryComponent part does not appear to be in the bluetooth panel; at least it's not referenced anywhere in the bluetooth code, as such, it should be covered elsewhere than in this merge proposal.

Brendan; I've spent the past two days writing the mocking for bluez 4; I'll add tests next.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:815
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1038/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2357
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/1932
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/230
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/230
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/230/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/230
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-mako/2537
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3571
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3571/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/10262
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-utopic/1620
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2176
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2176/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1038/rebuild

review: Needs Fixing (continuous-integration)

[Sebastien Bacher (seb128)]

> What is the property for the separators? I have looked and have been unable to find this in documentation.

http://developer.ubuntu.com/api/devel/ubuntu-13.04/qml/ui-toolkit/qml-ubuntu-components-listitems0-empty.html#showDivider-prop

[Sebastien Bacher (seb128)]

There is still a several hangs on start (trying on a desktop config if that makes a difference), even it's closer from 3 seconds than the 10 seconds it was before

[Sebastien Bacher (seb128)]

the icons also look wrong, do you know if design is working on providing better ones?

[Mathieu Trudel-Lapierre (cyphermox)]

Icons are provided in suru-icon-theme,I'd expect that's probably not the same on desktop.

[Mathieu Trudel-Lapierre (cyphermox)]

Tests will depend on https://code.launchpad.net/~mathieu-tl/libqtdbusmock/registertemplate/+merge/228232, fixes for libqtdbusmock.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:819
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1061/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2478/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/2006/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/253/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/253/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/253/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3721/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2258/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1061/rebuild

review: Needs Fixing (continuous-integration)

[lp:~cyphermox/ubuntu-system-settings/bluetooth-redesign]

820. By Mathieu Trudel-Lapierre on 2014-07-25

Hide divider below Discoverable/Not discoverable entry.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:820
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~mathieu-tl/ubuntu-system-settings/bluetooth-redesign/+merge/228327/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1067/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2516/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/2027/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/259/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/259/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/259/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3759/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2280/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1067/rebuild

review: Needs Fixing (continuous-integration)

[Manuel de la Peña (mandel)]

review: Needs Fixing

[lp:~cyphermox/ubuntu-system-settings/bluetooth-redesign]

821. By Mathieu Trudel-Lapierre on 2014-07-25

Fix leak in slotServiceDiscoveryDone

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:821
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~mathieu-tl/ubuntu-system-settings/bluetooth-redesign/+merge/228327/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1070/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2532/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/2039/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/262/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/262/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/262/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3775/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2292/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1070/rebuild

review: Needs Fixing (continuous-integration)

[lp:~cyphermox/ubuntu-system-settings/bluetooth-redesign]

822. By Mathieu Trudel-Lapierre on 2014-07-29

Change getStatusString as switch statement rather than a long if

823. By Mathieu Trudel-Lapierre on 2014-07-29

Merge from parent

824. By Mathieu Trudel-Lapierre on 2014-07-29

Chain constructors rather than calling an init function.

825. By Mathieu Trudel-Lapierre on 2014-07-29

Make path variable in removeDevice() have a shorter scope.

826. By Mathieu Trudel-Lapierre on 2014-07-29

Use a watcher to warn if setting the Trusted property on a device fails.

827. By Mathieu Trudel-Lapierre on 2014-07-29

Make bluezDevice QDBusInterface a QScopedPointer in slotDeviceCreated()

828. By Mathieu Trudel-Lapierre on 2014-07-29

Make it explicit that we're dealing with a QSharedPointer from getDeviceFromAddress().

829. By Mathieu Trudel-Lapierre on 2014-07-29

Cleanup CMakeLists for bluetooth plugin tests.

830. By Mathieu Trudel-Lapierre on 2014-07-29

Clean up m_bluezMock variable in FakeBluez in destructor

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:830
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1076/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2678/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/2142/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/268/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/268/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/268/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3921/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2400/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1076/rebuild

review: Needs Fixing (continuous-integration)

[Manuel de la Peña (mandel)]

review: Needs Fixing

[lp:~cyphermox/ubuntu-system-settings/bluetooth-redesign]

831. By Mathieu Trudel-Lapierre on 2014-07-30

Pass parent through the Bluetooth constructors

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:831
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1080/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2689/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/2151/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/272/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/272/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/272/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3932/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2409/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1080/rebuild

review: Needs Fixing (continuous-integration)

[lp:~cyphermox/ubuntu-system-settings/bluetooth-redesign]

832. By Mathieu Trudel-Lapierre on 2014-07-30

Make discoverServices() get called from a timer in a separate thread rather than blocking UI while we wait for the device to settle

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:832
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1089/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2737/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/2179/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/281/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/281/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/281/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3980/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2438/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1089/rebuild

review: Needs Fixing (continuous-integration)

[Sebastien Bacher (seb128)]

There is some merge conflicts there, needs a rebase on current trunk.

Otherwise looks fine to me to land, it's not perfect but we can fix small issues later. We need the libqtdbusmock changes to land first still though

review: Needs Fixing

[lp:~cyphermox/ubuntu-system-settings/bluetooth-redesign]

833. By Mathieu Trudel-Lapierre on 2014-07-31

Merge from parent

[Manuel de la Peña (mandel)]

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:833
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1113/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2839/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/2259/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/305/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/305/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/305/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4082/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2522/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1113/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:833
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1118/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2872
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/2282
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/310
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/310
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/310/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/310
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-mako/2942
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4115
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4115/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/10813
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-utopic/1887
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2546
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2546/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1118/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:833
http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-ci/1128/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2928
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/2317
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-amd64-ci/320
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/320
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-armhf-ci/320/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-system-settings-utopic-i386-ci/320
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-mako/2990
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4171
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/4171/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/10875
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-utopic/1917
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2582
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/2582/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-system-settings-ci/1128/rebuild

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-07-14 00:05:30 +0000
+++ CMakeLists.txt	2014-07-31 14:30:31 +0000
@@ -41,6 +41,8 @@
 pkg_search_module(TIMEZONEMAP REQUIRED timezonemap)
 pkg_search_module(ICU REQUIRED icu-i18n)
 pkg_search_module(ANDR_PROP libandroid-properties)
+pkg_check_modules(QTDBUSMOCK REQUIRED libqtdbusmock-1 REQUIRED)
+pkg_check_modules(QTDBUSTEST REQUIRED libqtdbustest-1 REQUIRED)
 pkg_search_module(POLKIT_AGENT polkit-agent-1)
 
 find_program(XGETTEXT_BIN xgettext)

=== modified file 'debian/changelog'
--- debian/changelog	2014-07-30 19:48:03 +0000
+++ debian/changelog	2014-07-31 14:30:31 +0000
@@ -1,3 +1,22 @@
+ubuntu-system-settings (0.3+14.10.20140730-0ubuntu2) UNRELEASED; urgency=medium
+
+  * Bluetooth UI redesign:
+    - Redesign the UI to follow the specification.
+    - Create devices only when attempting to connect.
+    - Bugfixes for displaying icons for devices.
+    - Show new icons for common device types.
+    - Support more device types.
+    - Show Trusted (known) devices in a separate list from the devices detected
+      by Discovery.
+    - Allow for a way to forget (unpair) a known device. (LP: #1336197)
+    - Follow the state of the Bluetooth adapter for whether Bluetooth
+      is enabled. (LP: #1272317)
+    - Miscellaneous bug fixes.
+  * debian/control: add Build-Depends on libqtdbusmock1-dev and
+    libqtdbustest1-dev for Bluetooth testing.
+
+ -- Mathieu Trudel-Lapierre <[e-mail]>  Thu, 17 Jul 2014 14:46:42 -0400
+
 ubuntu-system-settings (0.3+14.10.20140730-0ubuntu1) utopic; urgency=low
 
   [ CI bot ]

=== modified file 'debian/control'
--- debian/control	2014-07-30 19:47:49 +0000
+++ debian/control	2014-07-31 14:30:31 +0000
@@ -28,6 +28,8 @@
                libubuntuoneauth-2.0-dev,
                libubuntu-download-manager-client-dev,
                libubuntu-download-manager-common-dev,
+               libqtdbusmock1-dev (>= 0.2+14.04.20140724),
+               libqtdbustest1-dev,
                xvfb,
                cmake,
                pep8,

=== modified file 'plugins/bluetooth/PageComponent.qml'
--- plugins/bluetooth/PageComponent.qml	2014-06-20 21:56:15 +0000
+++ plugins/bluetooth/PageComponent.qml	2014-07-31 14:30:31 +0000
@@ -65,17 +65,23 @@
         }
     }
 
-    function getDisplayName(connection, displayName) {
-      if (connection == Device.Connecting)
-        // TRANSLATORS: %1 is the display name of the device that is connecting
-        return i18n.tr("%1 (Connecting…)").arg(displayName);
-      else if (connection == Device.Disconnecting)
-        // TRANSLATORS: %1 is the display name of the device that is disconnecting
-        return i18n.tr("%1 (Disconnecting…)").arg(displayName);
-      else
+    function getDisplayName(type, displayName) {
+        /* TODO: If the device requires a PIN, show ellipsis.
+         * Right now we don't have a way to check this, just return the name
+         */
         return displayName;
     }
 
+    function getStatusString(connection) {
+      switch (connection) {
+      case Device.Connected:     return i18n.tr("Connected");
+      case Device.Connecting:    return i18n.tr("Connecting…");
+      case Device.Disconnecting: return i18n.tr("Disconnecting…");
+      case Device.Disconnected:  return i18n.tr("Disconnected");
+      default:                   return i18n.tr("Unknown");
+      }
+    }
+
     function getTypeString(type) {
         switch (type) {
         case Device.Computer:   return i18n.tr("Computer");
@@ -132,6 +138,7 @@
                     id: btSwitch
                     // Cannot use onCheckedChanged as this triggers a loop
                     onClicked: bluetoothActionGroup.enabled.activate()
+                    checked: backend.powered
                 }
                 Component.onCompleted: clicked.connect(btSwitch.clicked)
             }
@@ -143,13 +150,16 @@
             }
 
             // Discoverability
-            ListItem.Subtitled {
+            ListItem.Standard {
                 enabled: bluetoothActionGroup.enabled
+                showDivider: false
 
                 Rectangle {
                     color: "transparent"
                     anchors.fill: parent
                     anchors.topMargin: units.gu(1)
+                    anchors.leftMargin: units.gu(2)
+                    anchors.rightMargin: units.gu(2)
 
                     Label {
                         anchors {
@@ -180,8 +190,8 @@
                             right: parent.right
                             topMargin: units.gu(1)
                         }
-                        visible: !backend.discoverable
-                        running: !backend.discoverable
+                        visible: backend.powered && !backend.discoverable
+                        running: true
                     }
                 }
             }
@@ -204,12 +214,18 @@
 
                 model: backend.connectedDevices
                 delegate: ListItem.Standard {
-                    iconName: iconName
-                    text: getDisplayName(connection, displayName)
+                    iconSource: iconPath
+                    iconFrame: false
+                    text: getDisplayName(type, displayName)
+                    control: ActivityIndicator {
+                        visible: connection == Device.Connecting
+                        running: true
+                    }
                     onClicked: {
                         backend.setSelectedDevice(addressName);
                         pageStack.push(connectedDevicePage);
                     }
+                    progression: true
                 }
             }
 
@@ -217,10 +233,10 @@
 
             ListItem.Standard {
                 id: disconnectedHeader
-                text: connectedList.visible ? i18n.tr("Connect a different device:") : i18n.tr("Connect another device:")
+                text: connectedList.visible ? i18n.tr("Connect another device:") : i18n.tr("Connect a device:")
                 enabled: bluetoothActionGroup.enabled
                 control: ActivityIndicator {
-                    visible: backend.discovering
+                    visible: backend.powered && backend.discovering
                     running: true
                 }
             }
@@ -234,19 +250,49 @@
 
                 model: backend.disconnectedDevices
                 delegate: ListItem.Standard {
-                    iconName: iconName
-                    text: getDisplayName(connection, displayName)
+                    iconSource: iconPath
+                    iconFrame: false
+                    text: getDisplayName(type, displayName)
+                    enabled: backend.isSupportedType(type)
                     onClicked: {
-                        backend.stopDiscovery();
-                        backend.connectDevice(addressName);
+                        backend.setSelectedDevice(addressName);
+                        pageStack.push(connectedDevicePage);
                     }
+                    progression: true
                 }
             }
             ListItem.Standard {
                 id: disconnectedNone
                 text: i18n.tr("None detected")
                 visible: !disconnectedList.visible
-                enabled: !backend.discovering
+                enabled: false
+            }
+
+            //  Devices that connect automatically
+            ListItem.Standard {
+                id: autoconnectHeader
+                text: i18n.tr("Connect automatically when detected:")
+                visible: autoconnectList.visible
+                enabled: bluetoothActionGroup.enabled
+            }
+            ListView {
+                id: autoconnectList
+                width: parent.width
+                height: autoconnectHeader.height * count
+
+                visible: bluetoothActionGroup.enabled && (count > 0)
+
+                model: backend.autoconnectDevices
+                delegate: ListItem.Standard {
+                    iconSource: iconPath
+                    iconFrame: false
+                    text: getDisplayName(type, displayName)
+                    onClicked: {
+                        backend.setSelectedDevice(addressName);
+                        pageStack.push(connectedDevicePage);
+                    }
+                    progression: true
+                }
             }
         }
     }
@@ -263,22 +309,93 @@
                 text: i18n.tr("Name")
                 value: backend.selectedDevice ? backend.selectedDevice.name : i18n.tr("None")
             }
+            ListItem.Standard {
+                Rectangle {
+                    color: "transparent"
+                    anchors.fill: parent
+                    anchors.topMargin: units.gu(1)
+                    anchors.leftMargin: units.gu(2)
+                    anchors.rightMargin: units.gu(2)
+
+                    Label {
+                        anchors {
+                            top: parent.top
+                            left: parent.left
+                            topMargin: units.gu(1)
+                        }
+                        height: units.gu(3)
+                        text: i18n.tr("Type")
+                    }
+                    Image {
+                        anchors {
+                            right: deviceType.left
+                            rightMargin: units.gu(1)
+                        }
+                        height: units.gu(4)
+                        width: units.gu(4)
+                        source: backend.selectedDevice ? backend.selectedDevice.iconName : ""
+                    }
+                    Label {
+                        id: deviceType
+                        anchors {
+                            top: parent.top
+                            right: parent.right
+                            topMargin: units.gu(1)
+                        }
+                        height: units.gu(3)
+                        text: getTypeString(backend.selectedDevice ? backend.selectedDevice.type : Device.OTHER)
+                    }
+                }
+            }
             ListItem.SingleValue {
-                text: i18n.tr("Type")
-                value: getTypeString(backend.selectedDevice ? backend.selectedDevice.type : Device.OTHER)
+                text: i18n.tr("Status")
+                value: getStatusString(backend.selectedDevice ? backend.selectedDevice.connection : Device.Disconnected)
             }
             ListItem.SingleValue {
                 text: i18n.tr("Signal Strength")
                 value: getSignalString(backend.selectedDevice ? backend.selectedDevice.strength : Device.None)
             }
-            ListItem.SingleControl {
-                control: Button {
-                    text: i18n.tr("Disconnect")
-                    width: parent.width - units.gu(8)
-                    onClicked: {
-                        backend.disconnectDevice();
-                        pageStack.pop();
-                    }
+            ListItem.Standard {
+                id: trustedCheck
+                text: i18n.tr("Connect automatically when detected:")
+                control: CheckBox {
+                    onClicked: {
+                        if (backend.selectedDevice) {
+                            backend.selectedDevice.trusted = !backend.selectedDevice.trusted
+                        }
+                    }
+                    checked: backend.selectedDevice ? backend.selectedDevice.trusted : false
+                }
+                Component.onCompleted:
+                    clicked.connect(trustedCheck.clicked)
+            }
+            ListItem.SingleControl {
+                control: Button {
+                    text: backend.selectedDevice && (backend.selectedDevice.connection == Device.Connected || backend.selectedDevice.connection == Device.Connecting) ? i18n.tr("Disconnect") : i18n.tr("Connect")
+                    width: parent.width - units.gu(8)
+                    onClicked: {
+                        if (backend.selectedDevice
+                            && (backend.selectedDevice.connection == Device.Connected
+                                || backend.selectedDevice.connection == Device.Connecting)) {
+                            backend.disconnectDevice();
+                        } else {
+                            backend.stopDiscovery()
+                            backend.connectDevice(backend.selectedDevice.address);
+                        }
+                        pageStack.pop();
+                    }
+                    visible: backend.selectedDevice ? true : false
+                }
+            }
+            ListItem.SingleControl {
+                control: Button {
+                    text: i18n.tr("Forget this device")
+                    width: parent.width - units.gu(8)
+                    onClicked: {
+                        backend.removeDevice();
+                        pageStack.pop();
+                    }
+                    enabled: backend.selectedDevice && backend.selectedDevice.path.length > 0 ? true : false
                 }
             }
         }

=== modified file 'plugins/bluetooth/bluetooth.cpp'
--- plugins/bluetooth/bluetooth.cpp	2014-06-20 21:56:15 +0000
+++ plugins/bluetooth/bluetooth.cpp	2014-07-31 14:30:31 +0000
@@ -26,8 +26,13 @@
 #include "dbus-shared.h"
 
 Bluetooth::Bluetooth(QObject *parent):
+    Bluetooth(QDBusConnection::systemBus(), parent)
+{
+}
+
+Bluetooth::Bluetooth(const QDBusConnection &dbus, QObject *parent):
     QObject(parent),
-    m_dbus(QDBusConnection::systemBus()),
+    m_dbus(dbus),
     m_devices(m_dbus),
     m_agent(m_dbus, m_devices)
 {
@@ -36,28 +41,27 @@
     if(!m_dbus.registerObject(DBUS_AGENT_PATH, &m_agent))
         qFatal("Couldn't register agent at " DBUS_AGENT_PATH);
 
-    QVector<Device::Type> types;
-    types.append(Device::Type::Headset);
-    types.append(Device::Type::Headphones);
-    types.append(Device::Type::OtherAudio);
-    m_connectedDevices.filterOnType(types);
     m_connectedDevices.filterOnConnections(Device::Connection::Connected |
+                                           Device::Connection::Connecting |
                                            Device::Connection::Disconnecting);
     m_connectedDevices.setSourceModel(&m_devices);
 
-    m_disconnectedDevices.filterOnType(types);
-    m_disconnectedDevices.filterOnConnections(Device::Connection::Connecting |
-                                              Device::Connection::Disconnected);
+    m_disconnectedDevices.filterOnConnections(Device::Connection::Disconnected);
+    m_disconnectedDevices.filterOnTrusted(false);
     m_disconnectedDevices.setSourceModel(&m_devices);
 
+    m_autoconnectDevices.filterOnConnections(Device::Connection::Disconnected);
+    m_autoconnectDevices.filterOnTrusted(true);
+    m_autoconnectDevices.setSourceModel(&m_devices);
+
+    QObject::connect(&m_devices, SIGNAL(poweredChanged(bool)),
+                     this, SIGNAL(poweredChanged(bool)));
+
     QObject::connect(&m_devices, SIGNAL(discoveringChanged(bool)),
                      this, SIGNAL(discoveringChanged(bool)));
 
     QObject::connect(&m_devices, SIGNAL(discoverableChanged(bool)),
                      this, SIGNAL(discoverableChanged(bool)));
-
-    QObject::connect(&m_agent, SIGNAL(onPairingDone()),
-                     this, SLOT(onPairingDone()));
 }
 
 void Bluetooth::setSelectedDevice(const QString &address)
@@ -83,6 +87,20 @@
     m_devices.stopDiscovery();
 }
 
+bool Bluetooth::isSupportedType(const int type)
+{
+    switch((Device::Type)type) {
+
+    case Device::Type::Headset:
+    case Device::Type::Headphones:
+    case Device::Type::OtherAudio:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
 /***
 ****
 ***/
@@ -119,6 +137,13 @@
     return ret;
 }
 
+QAbstractItemModel * Bluetooth::getAutoconnectDevices()
+{
+    auto ret = &m_autoconnectDevices;
+    QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
+    return ret;
+}
+
 
 /***
 ****
@@ -128,7 +153,7 @@
 {
     Device::Type type;
 
-    if (m_selectedDevice)
+    if (m_selectedDevice) {
         type = m_selectedDevice->getType();
         if (type == Device::Type::Headset)
             m_selectedDevice->disconnect(Device::ConnectionMode::Audio);
@@ -136,6 +161,9 @@
             m_selectedDevice->disconnect(Device::ConnectionMode::Audio);
         else if (type == Device::Type::OtherAudio)
             m_selectedDevice->disconnect(Device::ConnectionMode::Audio);
+    } else {
+        qWarning() << "No selected device to disconnect";
+    }
 }
 
 void Bluetooth::connectDevice(const QString &address)
@@ -144,8 +172,10 @@
     auto device = m_devices.getDeviceFromAddress(address);
     Device::Type type;
 
-    if (!device)
+    if (!device) {
+        qWarning() << "No device to connect.";
         return;
+    }
 
     type = device->getType();
     if (type == Device::Type::Headset)
@@ -155,24 +185,21 @@
     else if (type == Device::Type::OtherAudio)
         connMode = Device::ConnectionMode::Audio;
 
-    if (device->isPaired()) {
+    if (device->isTrusted()) {
         device->connect(connMode);
     } else {
-        m_connectAfterPairing[address] = connMode;
-        m_devices.pairDevice(address);
+        m_devices.addConnectAfterPairing(address, connMode);
+        m_devices.createDevice(address);
     }
 }
 
-void Bluetooth::onPairingDone()
+void Bluetooth::removeDevice()
 {
-    QMapIterator<QString,Device::ConnectionMode> it(m_connectAfterPairing);
-    while (it.hasNext()) {
-        it.next();
-        const QString &address = it.key();
-        auto device = m_devices.getDeviceFromAddress(address);
-        if (device)
-            device->connect(it.value());
+    if (m_selectedDevice) {
+        QString path = m_selectedDevice->getPath();
+        m_devices.removeDevice(path);
+    } else {
+        qWarning() << "No selected device to remove.";
     }
+}
 
-    m_connectAfterPairing.clear();
-}

=== modified file 'plugins/bluetooth/bluetooth.h'
--- plugins/bluetooth/bluetooth.h	2014-06-20 21:56:15 +0000
+++ plugins/bluetooth/bluetooth.h	2014-07-31 14:30:31 +0000
@@ -39,6 +39,10 @@
                 READ getDisconnectedDevices
                 CONSTANT)
 
+    Q_PROPERTY (QAbstractItemModel* autoconnectDevices
+                READ getAutoconnectDevices
+                CONSTANT)
+
     Q_PROPERTY (QObject * selectedDevice
                 READ getSelectedDevice
                 NOTIFY selectedDeviceChanged);
@@ -46,6 +50,10 @@
     Q_PROPERTY (QObject * agent
                 READ getAgent);
 
+    Q_PROPERTY (bool powered
+                READ isPowered
+                NOTIFY poweredChanged);
+
     Q_PROPERTY (bool discovering
                 READ isDiscovering
                 NOTIFY discoveringChanged);
@@ -56,30 +64,33 @@
 
 Q_SIGNALS:
     void selectedDeviceChanged();
+    void poweredChanged(bool powered);
     void discoveringChanged(bool isActive);
     void discoverableChanged(bool isActive);
 
-private Q_SLOTS:
-    void onPairingDone();
-
 public:
     Bluetooth(QObject *parent = 0);
+    Bluetooth(const QDBusConnection &dbus, QObject *parent = 0);
     ~Bluetooth() {}
 
     Q_INVOKABLE QString adapterName() const { return m_devices.adapterName(); }
     Q_INVOKABLE void setSelectedDevice(const QString &address);
     Q_INVOKABLE void connectDevice(const QString &address);
     Q_INVOKABLE void disconnectDevice();
+    Q_INVOKABLE void removeDevice();
     Q_INVOKABLE void toggleDiscovery();
     Q_INVOKABLE void startDiscovery();
     Q_INVOKABLE void stopDiscovery();
+    Q_INVOKABLE static bool isSupportedType(const int type);
 
 public:
     Agent * getAgent();
     Device * getSelectedDevice();
     QAbstractItemModel * getConnectedDevices();
     QAbstractItemModel * getDisconnectedDevices();
+    QAbstractItemModel * getAutoconnectDevices();
 
+    bool isPowered() const { return m_devices.isPowered(); }
     bool isDiscovering() const { return m_devices.isDiscovering(); }
     bool isDiscoverable() const { return m_devices.isDiscoverable(); }
 
@@ -88,11 +99,10 @@
     DeviceModel m_devices;
     DeviceFilter m_connectedDevices;
     DeviceFilter m_disconnectedDevices;
+    DeviceFilter m_autoconnectDevices;
     QSharedPointer<Device> m_selectedDevice;
 
     Agent m_agent;
-
-    QMap<QString,Device::ConnectionMode> m_connectAfterPairing;
 };
 
 #endif // BLUETOOTH_H

=== modified file 'plugins/bluetooth/device.cpp'
--- plugins/bluetooth/device.cpp	2014-06-20 20:59:31 +0000
+++ plugins/bluetooth/device.cpp	2014-07-31 14:30:31 +0000
@@ -19,6 +19,8 @@
 
 #include <QDBusReply>
 #include <QDebug> // qWarning()
+#include <QThread>
+#include <QTimer>
 
 #include "dbus-shared.h"
 #include "device.h"
@@ -27,8 +29,18 @@
 ****
 ***/
 
+Device::Device(const QMap<QString,QVariant> &properties)
+{
+    setProperties(properties);
+}
+
 Device::Device(const QString &path, QDBusConnection &bus)
 {
+    initDevice(path, bus);
+}
+
+void Device::initDevice(const QString &path, QDBusConnection &bus)
+{
     /* whenever any of the properties changes,
        trigger the catch-all deviceChanged() signal */
     QObject::connect(this, SIGNAL(nameChanged()), this, SIGNAL(deviceChanged()));
@@ -46,6 +58,8 @@
     initInterface(m_audioSourceInterface, path, "org.bluez.AudioSource", bus);
     initInterface(m_audioSinkInterface,   path, "org.bluez.AudioSink",   bus);
     initInterface(m_headsetInterface,     path, "org.bluez.Headset",     bus);
+
+    Q_EMIT(pathChanged());
 }
 
 /***
@@ -94,38 +108,142 @@
     }
 }
 
+void Device::connectPending()
+{
+    if (m_paired && !m_trusted) {
+        /* Give the device a bit of time to settle.
+         * Once service discovery is done, it will call connect() on the
+         * pending interfaces.
+         */
+        QTimer::singleShot(1, this, SLOT(discoverServices()));
+    }
+}
+
 /***
 ****
 ***/
 
+void Device::addConnectAfterPairing(ConnectionMode mode)
+{
+    m_connectAfterPairing.append(mode);
+}
+
+void Device::slotServiceDiscoveryDone(QDBusPendingCallWatcher *call)
+{
+    QDBusPendingReply<void> reply = *call;
+
+    if (!reply.isError()) {
+        while (!m_connectAfterPairing.isEmpty()) {
+            ConnectionMode mode = m_connectAfterPairing.takeFirst();
+            connect(mode);
+        }
+    } else {
+        qWarning() << "Could not initiate service discovery:"
+                   << reply.error().message();
+    }
+    call->deleteLater();
+}
+
+void Device::discoverServices()
+{
+    if (m_deviceInterface) {
+        QDBusPendingCall pcall
+            = m_deviceInterface->asyncCall("DiscoverServices",
+                                           QLatin1String(""));
+
+        QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pcall,
+                                                                       this);
+        QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
+                         this,
+                         SLOT(slotServiceDiscoveryDone(QDBusPendingCallWatcher*)));
+    } else {
+        qWarning() << "Can't do service discovery: the device interface is not ready.";
+    }
+}
+
+void Device::callInterface(const QSharedPointer<QDBusInterface> &interface, const QString &method)
+{
+    QDBusReply<void> reply;
+    constexpr int maxTries = 4;
+    int retryCount = 0;
+
+    while (retryCount < maxTries) {
+        reply = interface->call(method);
+        if (reply.isValid())
+            break;
+        QThread::msleep(500);
+        retryCount++;
+    }
+
+    if (retryCount >= maxTries && !reply.isValid()) {
+        qWarning() << "Could not" << method << "the interface" << interface->interface()
+                   << ":" << reply.error().message();
+    }
+}
+
 void Device::disconnect(ConnectionMode mode)
 {
+    QSharedPointer<QDBusInterface> interface;
+
     if (m_headsetInterface && (mode == HeadsetMode))
-        m_headsetInterface->asyncCall("Disconnect");
+        interface = m_headsetInterface;
     else if (m_audioInterface && (mode == Audio))
-        m_audioInterface->asyncCall("Disconnect");
-    else
+        interface = m_audioInterface;
+    else {
         qWarning() << "Unhandled connection mode" << mode;
+        return;
+    }
+
+    callInterface(interface, "Disconnect");
 }
 
 void Device::connect(ConnectionMode mode)
 {
+    QSharedPointer<QDBusInterface> interface;
+
     if (m_headsetInterface && (mode == HeadsetMode))
-        m_headsetInterface->asyncCall("Connect");
+        interface = m_headsetInterface;
     else if (m_audioInterface && (mode == Audio))
-        m_audioInterface->asyncCall("Connect");
-    else
+        interface = m_audioInterface;
+    else {
         qWarning() << "Unhandled connection mode" << mode;
-}
-
-void Device::makeTrusted()
-{
-        QVariant value;
-        QDBusVariant trusted(true);
-
-        value.setValue(trusted);
-
-        m_deviceInterface->asyncCall("SetProperty", "Trusted", value);
+        return;
+    }
+
+    callInterface(interface, "Connect");
+}
+
+void Device::slotMakeTrustedDone(QDBusPendingCallWatcher *call)
+{
+    QDBusPendingReply<void> reply = *call;
+
+    if (reply.isError()) {
+        qWarning() << "Could not set device as trusted:"
+                   << reply.error().message();
+    }
+    call->deleteLater();
+}
+
+void Device::makeTrusted(bool trusted)
+{
+    QVariant value;
+    QDBusVariant variant(trusted);
+
+    value.setValue(variant);
+
+    if (m_deviceInterface) {
+        QDBusPendingCall pcall
+            = m_deviceInterface->asyncCall("SetProperty", "Trusted", value);
+
+        QDBusPendingCallWatcher *watcher
+            = new QDBusPendingCallWatcher(pcall, this);
+        QObject::connect(watcher,
+                         SIGNAL(finished(QDBusPendingCallWatcher*)),
+                         this,
+                         SLOT(slotServiceDiscoveryDone(QDBusPendingCallWatcher*)));
+    } else {
+        qWarning() << "Can't set device trusted before it is added in BlueZ";
+    }
 }
 
 /***
@@ -198,12 +316,41 @@
 
     const auto type = getType();
 
-    if (type == Type::Headset || type == Type::Headphones || type == Type::OtherAudio)
-        setIconName("image://theme/audio-headset");
-    else if (type == Type::Phone)
-        setIconName("image://theme/phone");
-    else if (!m_fallbackIconName.isEmpty())
+    switch (type) {
+    case Type::Headset:
+        setIconName("image://theme/audio-headset-symbolic");
+        break;
+    case Type::Headphones:
+        setIconName("image://theme/audio-headphones-symbolic");
+        break;
+    case Type::Carkit:
+        setIconName("image://theme/audio-carkit-symbolic");
+        break;
+    case Type::Speakers:
+    case Type::OtherAudio:
+        setIconName("image://theme/audio-speakers-symbolic");
+        break;
+    case Type::Mouse:
+        setIconName("image://theme/input-mouse-symbolic");
+        break;
+    case Type::Keyboard:
+        setIconName("image://theme/input-keyboard-symbolic");
+        break;
+    case Type::Cellular:
+        setIconName("image://theme/phone-cellular-symbolic");
+        break;
+    case Type::Smartphone:
+        setIconName("image://theme/phone-smartphone-symbolic");
+        break;
+    case Type::Phone:
+        setIconName("image://theme/phone-uncategorized-symbolic");
+        break;
+    case Type::Computer:
+        setIconName("image://theme/computer-symbolic");
+        break;
+    default: 
         setIconName(QString("image://theme/%1").arg(m_fallbackIconName));
+    }
 }
 
 void Device::updateConnection()
@@ -224,7 +371,7 @@
         c = m_isConnected ? Connection::Connected : Connection::Disconnected;
 
     if (m_isConnected && m_paired && !m_trusted)
-        makeTrusted();
+        makeTrusted(true);
 
     setConnection(c);
 }
@@ -245,6 +392,7 @@
         setType(getTypeFromClass(value.toUInt()));
     } else if (key == "Paired") { // org.bluez.Device
         setPaired(value.toBool());
+        connectPending();
         updateConnection();
     } else if (key == "Trusted") { // org.bluez.Device
         setTrusted(value.toBool());
@@ -269,13 +417,13 @@
     case 0x02:
         switch ((c & 0xfc) >> 2) {
         case 0x01:
-        case 0x02:
+            return Type::Cellular;
         case 0x03:
-        case 0x05:
-            return Type::Phone;
-
+            return Type::Smartphone;
         case 0x04:
             return Type::Modem;
+        default:
+            return Type::Phone;
         }
         break;
 
@@ -288,9 +436,15 @@
         case 0x02:
             return Type::Headset;
 
+        case 0x05:
+            return Type::Speakers;
+
         case 0x06:
             return Type::Headphones;
 
+        case 0x08:
+            return Type::Carkit;
+
         case 0x0b: // vcr
         case 0x0c: // video camera
         case 0x0d: // camcorder

=== modified file 'plugins/bluetooth/device.h'
--- plugins/bluetooth/device.h	2014-06-19 15:10:43 +0000
+++ plugins/bluetooth/device.h	2014-07-31 14:30:31 +0000
@@ -29,6 +29,10 @@
 {
     Q_OBJECT
 
+    Q_PROPERTY(QString path
+               READ getPath
+               NOTIFY pathChanged)
+
     Q_PROPERTY(QString name
                READ getName
                NOTIFY nameChanged)
@@ -51,6 +55,7 @@
 
     Q_PROPERTY(bool trusted
                READ isTrusted
+               WRITE makeTrusted
                NOTIFY trustedChanged)
 
     Q_PROPERTY(Connection connection
@@ -63,9 +68,9 @@
 
 public:
 
-    enum Type { Other, Computer, Phone, Modem, Network, Headset,
-                Headphones, Video, OtherAudio, Joypad, Keypad,
-                Keyboard, Tablet, Mouse, Printer, Camera };
+    enum Type { Other, Computer, Cellular, Smartphone, Phone, Modem, Network,
+                Headset, Speakers, Headphones, Video, OtherAudio, Joypad,
+                Keypad, Keyboard, Tablet, Mouse, Printer, Camera, Carkit };
 
     enum Strength { None, Poor, Fair, Good, Excellent };
 
@@ -80,6 +85,7 @@
     Q_DECLARE_FLAGS(Connections, Connection)
 
 Q_SIGNALS:
+    void pathChanged();
     void nameChanged();
     void iconNameChanged();
     void addressChanged();
@@ -99,7 +105,7 @@
     bool isTrusted() const { return m_trusted; }
     Connection getConnection() const { return m_connection; }
     Strength getStrength() const { return m_strength; }
-    QString getPath() const { return m_deviceInterface->path(); }
+    QString getPath() const { return m_deviceInterface ? m_deviceInterface->path() : QString(); }
 
   private:
     QString m_name;
@@ -118,6 +124,7 @@
     QSharedPointer<QDBusInterface> m_audioSourceInterface;
     QSharedPointer<QDBusInterface> m_audioSinkInterface;
     QSharedPointer<QDBusInterface> m_headsetInterface;
+    QList<ConnectionMode> m_connectAfterPairing;
 
   protected:
     void setName(const QString &name);
@@ -135,14 +142,24 @@
     Device() {}
     ~Device() {}
     Device(const QString &path, QDBusConnection &bus);
+    Device(const QMap<QString,QVariant> &properties);
+    void initDevice(const QString &path, QDBusConnection &bus);
     bool isValid() const { return getType() != Type::Other; }
+    void callInterface(const QSharedPointer<QDBusInterface> &interface, const QString &method);
     void connect(ConnectionMode);
-    void makeTrusted();
+    void connectPending();
+    void makeTrusted(bool trusted);
     void disconnect(ConnectionMode);
     void setProperties(const QMap<QString,QVariant> &properties);
+    void addConnectAfterPairing(const ConnectionMode mode);
+
+  public Q_SLOTS:
+    void discoverServices();
 
   private Q_SLOTS:
     void slotPropertyChanged(const QString &key, const QDBusVariant &value);
+    void slotServiceDiscoveryDone(QDBusPendingCallWatcher *call);
+    void slotMakeTrustedDone(QDBusPendingCallWatcher *call);
 
   private:
     void updateProperties(QSharedPointer<QDBusInterface>);

=== modified file 'plugins/bluetooth/devicemodel.cpp'
--- plugins/bluetooth/devicemodel.cpp	2014-06-20 21:56:15 +0000
+++ plugins/bluetooth/devicemodel.cpp	2014-07-31 14:30:31 +0000
@@ -100,7 +100,7 @@
 
 void DeviceModel::startDiscovery()
 {
-    if (m_bluezAdapter && !m_isDiscovering) {
+    if (m_bluezAdapter && m_isPowered && !m_isDiscovering) {
         m_bluezAdapter->asyncCall("StartDiscovery");
         m_isDiscovering = true;
         Q_EMIT(discoveringChanged(m_isDiscovering));
@@ -236,6 +236,8 @@
         m_isPairable = value.toBool();
     } else if (key == "Discoverable") {
         setDiscoverable(value.toBool());
+    } else if (key == "Powered") {
+        setPowered(value.toBool());
     }
 }
 
@@ -247,6 +249,14 @@
     }
 }
 
+void DeviceModel::setPowered(bool powered)
+{
+    if (m_isPowered != powered) {
+        m_isPowered = powered;
+        Q_EMIT(poweredChanged(m_isPowered));
+    }
+}
+
 void DeviceModel::slotEnableDiscoverable()
 {
     trySetDiscoverable(true);
@@ -325,7 +335,36 @@
 
 void DeviceModel::slotDeviceCreated(const QDBusObjectPath &path)
 {
-    addDevice(path.path());
+    const QString service = "org.bluez";
+    const QString interface = "org.bluez.Device";
+    QScopedPointer<QDBusInterface> bluezDevice(
+        new QDBusInterface(service, path.path(), interface, m_dbus));
+
+    // A device was created. Now, we likely already have it, so let's find it
+    // again and finish the initialization.
+    QDBusReply<QMap<QString,QVariant> > properties
+        = bluezDevice->call("GetProperties");
+    if (properties.isValid()) {
+        QMapIterator<QString,QVariant> it(properties);
+        while (it.hasNext()) {
+            it.next();
+            if (it.key() == "Address") {
+                QSharedPointer<Device> device = getDeviceFromAddress(it.value().toString());
+
+                if (device) {
+                    device->initDevice(path.path(), m_dbus);
+                    QObject::connect(device.data(), SIGNAL(deviceChanged()),
+                                     this, SLOT(slotDeviceChanged()));
+                    addDevice(device);
+                } else {
+                    addDevice(path.path());
+                }
+                break;
+            }
+        }
+    } else {
+        qWarning() << "Invalid device properties for" << path.path();
+    }
 }
 
 void DeviceModel::slotDeviceFound(const QString                &address,
@@ -333,18 +372,26 @@
 {
     Q_UNUSED(properties);
 
-    auto device = getDeviceFromAddress(address);
-    if (!device) // hey, we haven't seen this one before
-        m_bluezAdapter->asyncCall(QLatin1String("CreateDevice"), address);
+    QSharedPointer<Device> device = getDeviceFromAddress(address);
+
+    if (!device) {
+        QSharedPointer<Device> device(new Device(properties));
+        if (device->isValid()) {
+            addDevice(device);
+        }
+    }
 }
 
 void DeviceModel::slotDeviceRemoved(const QDBusObjectPath &path)
 {
-    Q_UNUSED(path);
-
-    /* This is a no-op because we want to list both paired & unpaired devices.
-       So, keep it in m_devices until a call to slotDeviceDisappeared()
-       indicates the device has disappeared altogether */
+    /* Remove the device immediately, it will be listed again
+       once discovery results are returned.  */
+
+    auto device = getDeviceFromPath(path.path());
+
+    const int row = findRowFromAddress(device->getAddress());
+    if ((row >= 0))
+        removeRow(row);
 }
 
 void DeviceModel::slotDeviceDisappeared(const QString &address)
@@ -389,13 +436,63 @@
     return QSharedPointer<Device>();
 }
 
-void DeviceModel::pairDevice (const QString &address)
-{
-    if (m_bluezAdapter) {
-        m_bluezAdapter->asyncCall("CreatePairedDevice",
-                                  address,
-                                  qVariantFromValue(QDBusObjectPath(DBUS_AGENT_PATH)),
-                                  QString(DBUS_AGENT_CAPABILITY));
+void DeviceModel::addConnectAfterPairing(const QString &address, Device::ConnectionMode mode)
+{
+    QSharedPointer<Device> device = getDeviceFromAddress(address);
+    if (device) {
+        device->addConnectAfterPairing(mode);
+    } else {
+        qWarning() << "Device could not be found, can't add an operation";
+    }
+}
+
+void DeviceModel::slotCreateFinished(QDBusPendingCallWatcher *call)
+{
+    QDBusPendingReply<QDBusObjectPath> reply = *call;
+
+    if (reply.isError()) {
+        qWarning() << "Could not create device:" << reply.error().message();
+    }
+
+    call->deleteLater();
+}
+
+void DeviceModel::createDevice (const QString &address)
+{
+    if (m_bluezAdapter) {
+        QDBusPendingCall pcall = m_bluezAdapter->asyncCall("CreatePairedDevice",
+                                                           address,
+                                                           qVariantFromValue(QDBusObjectPath(DBUS_AGENT_PATH)),
+                                                           QString(DBUS_AGENT_CAPABILITY));
+
+        QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pcall, this);
+        QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
+                         this, SLOT(slotCreateFinished(QDBusPendingCallWatcher*)));
+    } else {
+        qWarning() << "Default adapter is not available for device creation";
+    }
+}
+
+void DeviceModel::slotRemoveFinished(QDBusPendingCallWatcher *call)
+{
+    QDBusPendingReply<void> reply = *call;
+
+    if (reply.isError()) {
+        qWarning() << "Could not remove device:" << reply.error().message();
+    }
+    call->deleteLater();
+}
+
+void DeviceModel::removeDevice (const QString &path)
+{
+    if (m_bluezAdapter) {
+        QDBusPendingCall pcall = m_bluezAdapter->asyncCall("RemoveDevice", qVariantFromValue(QDBusObjectPath(path)));
+
+        QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pcall, this);
+        QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
+                         this, SLOT(slotRemoveFinished(QDBusPendingCallWatcher*)));
+    } else {
+        qWarning() << "Default adapter is not available for device removal";
     }
 }
 
@@ -417,11 +514,12 @@
 
     if (Q_UNLIKELY(names.empty())) {
         names[Qt::DisplayRole] = "displayName";
-        names[Qt::DecorationRole] = "iconName";
+        names[IconRole] = "iconPath";
         names[TypeRole] = "type";
         names[StrengthRole] = "strength";
         names[ConnectionRole] = "connection";
         names[AddressRole] = "addressName";
+        names[TrustedRole] = "trusted";
     }
 
     return names;
@@ -440,7 +538,7 @@
             ret = device->isPaired() ? device->getName() : device->getName() + "…";
             break;
 
-        case Qt::DecorationRole:
+        case IconRole:
             ret = device->getIconName();
             break;
 
@@ -459,6 +557,10 @@
         case AddressRole:
             ret = device->getAddress();
             break;
+
+        case TrustedRole:
+            ret = device->isTrusted();
+            break;
         }
     }
 
@@ -486,6 +588,13 @@
     invalidateFilter();
 }
 
+void DeviceFilter::filterOnTrusted(bool trusted)
+{
+    m_trustedEnabled = true;
+    m_trustedFilter = trusted;
+    invalidateFilter();
+}
+
 bool DeviceFilter::filterAcceptsRow(int sourceRow,
                                     const QModelIndex &sourceParent) const
 {
@@ -502,6 +611,11 @@
         accepts = (m_connections & connection) != 0;
     }
 
+    if (accepts && m_trustedEnabled) {
+        const bool trusted = childIndex.model()->data(childIndex, DeviceModel::TrustedRole).value<bool>();
+        accepts = trusted == m_trustedFilter;
+    }
+
     return accepts;
 }
 

=== modified file 'plugins/bluetooth/devicemodel.h'
--- plugins/bluetooth/devicemodel.h	2014-06-20 21:56:15 +0000
+++ plugins/bluetooth/devicemodel.h	2014-07-31 14:30:31 +0000
@@ -46,12 +46,13 @@
     enum Roles
     {
       // Qt::DisplayRole holds device name
-      // Qt::DecorationRole has icon
       TypeRole = Qt::UserRole,
+      IconRole,
       StrengthRole,
       ConnectionRole,
       AddressRole,
-      LastRole = AddressRole
+      TrustedRole,
+      LastRole = TrustedRole
     };
 
     // implemented virtual methods from QAbstractTableModel
@@ -64,14 +65,18 @@
     QString adapterName() const { return m_adapterName; }
 
 public:
+    bool isPowered() const { return m_isPowered; }
     bool isDiscovering() const { return m_isDiscovering; }
     bool isDiscoverable() const { return m_isDiscoverable; }
-    void pairDevice(const QString &address);
+    void addConnectAfterPairing(const QString &address, Device::ConnectionMode mode);
+    void createDevice(const QString &address);
+    void removeDevice(const QString &path);
     void stopDiscovery();
     void startDiscovery();
     void toggleDiscovery();
 
 Q_SIGNALS: 
+    void poweredChanged(bool powered);
     void discoveringChanged(bool isDiscovering);
     void discoverableChanged(bool isDiscoverable);
 
@@ -84,6 +89,7 @@
 
     QString m_adapterName;
     QString m_adapterAddress;
+    bool m_isPowered = false;
     bool m_isPairable = false;
     bool m_isDiscovering = false;
     bool m_isDiscoverable = false;
@@ -92,6 +98,7 @@
     void restartTimer();
     void trySetDiscoverable(bool discoverable);
     void setDiscoverable(bool discoverable);
+    void setPowered(bool powered);
 
     QScopedPointer<QDBusInterface> m_bluezAdapter;
     void clearAdapter();
@@ -106,6 +113,8 @@
     void emitRowChanged(int row);
 
 private Q_SLOTS:
+    void slotCreateFinished(QDBusPendingCallWatcher *call);
+    void slotRemoveFinished(QDBusPendingCallWatcher *call);
     void slotPropertyChanged(const QString &key, const QDBusVariant &value);
     void slotTimeout();
     void slotEnableDiscoverable();
@@ -127,6 +136,7 @@
     virtual ~DeviceFilter() {}
     void filterOnType(const QVector<Device::Type>);
     void filterOnConnections(Device::Connections);
+    void filterOnTrusted(bool trusted);
 
 protected:
     virtual bool filterAcceptsRow(int, const QModelIndex&) const;
@@ -137,6 +147,8 @@
     bool m_typeEnabled = false;
     Device::Connections m_connections = Device::Connection::Connected;
     bool m_connectionsEnabled = false;
+    bool m_trustedEnabled = false;
+    bool m_trustedFilter = false;
 };
 
 #endif // BLUETOOTH_DEVICE_MODEL_H

=== modified file 'tests/plugins/CMakeLists.txt'
--- tests/plugins/CMakeLists.txt	2014-07-13 23:57:50 +0000
+++ tests/plugins/CMakeLists.txt	2014-07-31 14:30:31 +0000
@@ -1,1 +1,2 @@
 add_subdirectory(system-update)
+add_subdirectory(bluetooth)

=== added directory 'tests/plugins/bluetooth'
=== added file 'tests/plugins/bluetooth/CMakeLists.txt'
--- tests/plugins/bluetooth/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/plugins/bluetooth/CMakeLists.txt	2014-07-31 14:30:31 +0000
@@ -0,0 +1,61 @@
+set(XVFB_CMD xvfb-run -a -s "-screen 0 640x480x24")
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR}/plugins/bluetooth)
+include_directories(${QTDBUSMOCK_INCLUDE_DIRS})
+include_directories(${QTDBUSTEST_INCLUDE_DIRS})
+add_definitions(-DTESTS)
+
+add_executable(tst-bluetooth
+    tst_bluetooth.cpp
+    fakebluez.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/bluetooth.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/devicemodel.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/device.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/agent.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/agentadaptor.cpp
+)
+
+target_link_libraries(tst-bluetooth
+    ${QTDBUSMOCK_LIBRARIES}
+    ${QTDBUSTEST_LIBRARIES}
+)
+
+add_executable(tst-bluetooth-devicemodel
+    tst_devicemodel.cpp
+    fakebluez.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/bluetooth.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/devicemodel.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/device.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/agent.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/agentadaptor.cpp
+)
+
+target_link_libraries(tst-bluetooth-devicemodel
+    ${QTDBUSMOCK_LIBRARIES}
+    ${QTDBUSTEST_LIBRARIES}
+)
+
+add_executable(tst-bluetooth-device
+    tst_devicemodel.cpp
+    fakebluez.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/bluetooth.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/devicemodel.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/device.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/agent.cpp
+    ${CMAKE_SOURCE_DIR}/plugins/bluetooth/agentadaptor.cpp
+)
+
+target_link_libraries(tst-bluetooth-device
+    ${QTDBUSMOCK_LIBRARIES}
+    ${QTDBUSTEST_LIBRARIES}
+)
+
+qt5_use_modules(tst-bluetooth Qml Quick Core DBus Test)
+qt5_use_modules(tst-bluetooth-devicemodel Qml Quick Core DBus Test)
+qt5_use_modules(tst-bluetooth-device Qml Quick Core DBus Test)
+
+add_test(NAME tst-bluetooth
+         COMMAND ${XVFB_CMD} ${CMAKE_CURRENT_BINARY_DIR}/tst-bluetooth)
+add_test(NAME tst-bluetooth-devicemodel
+         COMMAND ${XVFB_CMD} ${CMAKE_CURRENT_BINARY_DIR}/tst-bluetooth-devicemodel)
+add_test(NAME tst-bluetooth-device
+         COMMAND ${XVFB_CMD} ${CMAKE_CURRENT_BINARY_DIR}/tst-bluetooth-device)

=== added file 'tests/plugins/bluetooth/fakebluez.cpp'
--- tests/plugins/bluetooth/fakebluez.cpp	1970-01-01 00:00:00 +0000
+++ tests/plugins/bluetooth/fakebluez.cpp	2014-07-31 14:30:31 +0000
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QDBusReply>
+#include <QDebug>
+
+#include "fakebluez.h"
+
+namespace Bluez {
+
+FakeBluez::FakeBluez(QObject *parent) :
+    QObject(parent),
+    m_dbusMock(m_dbusTestRunner)
+{
+    DBusMock::registerMetaTypes();
+
+    m_dbusMock.registerTemplate(BLUEZ_SERVICE, "bluez4",
+                                QDBusConnection::SystemBus);
+    m_dbusTestRunner.startServices();
+
+    m_bluezMock = new QDBusInterface(BLUEZ_SERVICE,
+                                     BLUEZ_MAIN_OBJECT,
+                                     BLUEZ_MOCK_IFACE,
+                                     m_dbusTestRunner.systemConnection());
+}
+
+FakeBluez::~FakeBluez()
+{
+    delete m_bluezMock;
+}
+
+QString
+FakeBluez::addAdapter(const QString &name, const QString &system_name)
+{
+    QDBusReply<QString> reply = m_bluezMock->call("AddAdapter",
+                                                    name, system_name);
+
+    if (reply.isValid()) {
+        m_currentAdapter = reply.value().replace("/org/bluez/", "");
+    } else {
+        qWarning() << "Failed to add mock adapter:" << reply.error().message();
+    }
+
+    return reply.isValid() ? reply.value() : QString();
+}
+
+QString
+FakeBluez::addDevice(const QString& name, const QString &address)
+{
+    QDBusReply<QString> reply = m_bluezMock->call("AddDevice",
+                                                  m_currentAdapter,
+                                                  address, name);
+
+    if (reply.isValid()) {
+        m_devices.append(reply.value());
+    } else {
+        qWarning() << "Failed to add mock device:" << reply.error().message();
+    }
+
+    return reply.isValid() ? reply.value() : QString();
+}
+
+QVariant
+FakeBluez::getProperty(const QString &path,
+                       const QString &interface,
+                       const QString &property)
+{
+    QDBusInterface iface(BLUEZ_SERVICE, path,
+                         "org.freedesktop.DBus.Properties",
+                         m_dbusTestRunner.systemConnection());
+
+    QDBusReply<QVariant> reply = iface.call("Get", interface, property);
+
+    if (reply.isValid()) {
+        return reply.value();
+    } else {
+        qWarning() << "Error getting property from mock:"
+                   << reply.error().message();
+    }
+
+    return reply.isValid() ? reply.value() : QVariant();
+}
+
+void
+FakeBluez::setProperty(const QString &path,
+                       const QString &interface,
+                       const QString &property,
+                       const QVariant &value)
+{
+    QDBusInterface iface(BLUEZ_SERVICE, path,
+                         interface,
+                         m_dbusTestRunner.systemConnection());
+
+    QDBusReply<void> reply = iface.call("SetProperty",
+                                        property, value);
+
+    if (!reply.isValid()) {
+        qWarning() << "Error setting property on mock:"
+                   << reply.error().message();
+    }
+}
+
+}

=== added file 'tests/plugins/bluetooth/fakebluez.h'
--- tests/plugins/bluetooth/fakebluez.h	1970-01-01 00:00:00 +0000
+++ tests/plugins/bluetooth/fakebluez.h	2014-07-31 14:30:31 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef FAKEBLUEZ_H
+#define FAKEBLUEZ_H
+
+#include <QObject>
+#include <QVariant>
+#include <QString>
+#include <QDBusConnection>
+#include <QDBusInterface>
+
+#include <libqtdbusmock/DBusMock.h>
+#include <libqtdbustest/DBusTestRunner.h>
+
+#define BLUEZ_SERVICE "org.bluez"
+#define BLUEZ_MAIN_OBJECT "/"
+#define BLUEZ_MOCK_IFACE "org.bluez.Mock"
+
+#define BLUEZ_MANAGER_IFACE "org.bluez.Manager"
+#define BLUEZ_ADAPTER_IFACE "org.bluez.Adapter"
+#define BLUEZ_DEVICE_IFACE "org.bluez.Device"
+#define BLUEZ_AUDIO_IFACE "org.bluez.Audio"
+
+using namespace QtDBusTest;
+using namespace QtDBusMock;
+
+namespace Bluez {
+
+class FakeBluez : public QObject
+{
+    Q_OBJECT
+
+private:
+    DBusMock m_dbusMock;
+    DBusTestRunner m_dbusTestRunner;
+
+    QDBusInterface *m_bluezMock;
+    QString m_currentAdapter;
+    QList<QString> m_devices;
+
+    QDBusInterface getInterface(const QString &path, const QString &interface);
+
+public:
+    explicit FakeBluez(QObject *parent = 0);
+
+    ~FakeBluez();
+
+    const QString currentAdapter() { return m_currentAdapter; }
+    const QList<QString> devices() { return m_devices; }
+    const QDBusConnection & dbus() { return m_dbusTestRunner.systemConnection(); }
+
+    QString addAdapter(const QString &name, const QString &system_name);
+    QString addDevice(const QString &name, const QString &address);
+
+    QVariant getProperty(const QString &path,
+                         const QString &interface,
+                         const QString &property);
+    
+    void setProperty(const QString &path,
+                     const QString &interface,
+                     const QString &property,
+                     const QVariant &value);
+
+};
+
+}
+
+#endif // FAKEBLUEZ_H

=== added file 'tests/plugins/bluetooth/tst_bluetooth.cpp'
--- tests/plugins/bluetooth/tst_bluetooth.cpp	1970-01-01 00:00:00 +0000
+++ tests/plugins/bluetooth/tst_bluetooth.cpp	2014-07-31 14:30:31 +0000
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QTest>
+#include <QSignalSpy>
+#include <QThread>
+
+#include "bluetooth.h"
+#include "device.h"
+#include "agent.h"
+#include "fakebluez.h"
+
+using namespace Bluez;
+
+class BluetoothTest: public QObject
+{
+    Q_OBJECT
+
+private:
+    FakeBluez *m_bluezMock;
+    Bluetooth *m_bluetooth;
+    QDBusConnection *m_dbus;
+
+private Q_SLOTS:
+    void init();
+    void testGotAdapter();
+    void testStartDiscovery();
+    void testStopDiscovery();
+    void testToggleDiscovery();
+    void testIsSupportedType();
+    void testIsDiscovering();
+    void cleanup();
+
+};
+
+void BluetoothTest::init()
+{
+    m_bluezMock = new FakeBluez();
+    m_bluezMock->addAdapter("new0", "bluetoothTest");
+    m_dbus = new QDBusConnection(m_bluezMock->dbus());
+    m_bluetooth = new Bluetooth(*m_dbus);
+}
+
+void BluetoothTest::cleanup()
+{
+    delete m_bluezMock;
+    delete m_bluetooth;
+}
+
+void BluetoothTest::testGotAdapter()
+{
+    QString expected = "bluetoothTest";
+    QString result;
+
+    result = m_bluetooth->adapterName();
+
+    QCOMPARE(result, expected);
+}
+
+void BluetoothTest::testStartDiscovery()
+{
+    bool expected = true;
+    QVariant result;
+
+    QSKIP("Fails due to a bug in bluez4 dbusmock template", SkipAll);
+
+    result = m_bluezMock->getProperty(m_bluezMock->currentAdapter(),
+                                      "org.bluez.Adapter",
+                                      "Discovering");
+    qWarning() << result;
+    QCOMPARE(result.toBool(), !expected);
+
+    m_bluetooth->startDiscovery();
+
+    result = m_bluezMock->getProperty(m_bluezMock->currentAdapter(),
+                                      "org.bluez.Adapter",
+                                      "Discovering");
+    qWarning() << result;
+    QCOMPARE(result.toBool(), expected);
+}
+
+void BluetoothTest::testStopDiscovery()
+{
+    bool expected = false;
+    QVariant result;
+
+    QSKIP("Fails due to a bug in bluez4 dbusmock template", SkipAll);
+
+    result = m_bluezMock->getProperty(m_bluezMock->currentAdapter(),
+                                      "org.bluez.Adapter",
+                                      "Discovering");
+    QCOMPARE(result.toBool(), !expected);
+
+    m_bluetooth->stopDiscovery();
+
+    result = m_bluezMock->getProperty(m_bluezMock->currentAdapter(),
+                                      "org.bluez.Adapter",
+                                      "Discovering");
+    QCOMPARE(result.toBool(), expected);
+}
+
+void BluetoothTest::testToggleDiscovery()
+{
+    QVariant result;
+
+    QSKIP("Fails due to a bug in bluez4 dbusmock template", SkipAll);
+
+    m_bluetooth->stopDiscovery();
+
+    result = m_bluezMock->getProperty(m_bluezMock->currentAdapter(),
+                                      "org.bluez.Adapter",
+                                      "Discovering");
+    QCOMPARE(result.toBool(), false);
+
+    m_bluetooth->toggleDiscovery();
+
+    result = m_bluezMock->getProperty(m_bluezMock->currentAdapter(),
+                                      "org.bluez.Adapter",
+                                      "Discovering");
+    QCOMPARE(result.toBool(), true);
+
+    m_bluetooth->toggleDiscovery();
+
+    result = m_bluezMock->getProperty(m_bluezMock->currentAdapter(),
+                                      "org.bluez.Adapter",
+                                      "Discovering");
+    QCOMPARE(result.toBool(), false);
+}
+
+void BluetoothTest::testIsSupportedType()
+{
+    QCOMPARE(Bluetooth::isSupportedType(Device::Type::Headset), true);
+    QCOMPARE(Bluetooth::isSupportedType(Device::Type::Mouse), false);
+    QCOMPARE(Bluetooth::isSupportedType(Device::Type::Tablet), false);
+}
+
+void BluetoothTest::testIsDiscovering()
+{
+    m_bluetooth->stopDiscovery();
+
+    QCOMPARE(m_bluetooth->isDiscovering(), false);
+
+    m_bluetooth->startDiscovery();
+
+    QCOMPARE(m_bluetooth->isDiscovering(), true);
+
+    m_bluetooth->toggleDiscovery();
+
+    QCOMPARE(m_bluetooth->isDiscovering(), false);
+
+    m_bluetooth->toggleDiscovery();
+
+    QCOMPARE(m_bluetooth->isDiscovering(), true);
+}
+
+QTEST_MAIN(BluetoothTest);
+#include "tst_bluetooth.moc"

=== added file 'tests/plugins/bluetooth/tst_device.cpp'
--- tests/plugins/bluetooth/tst_device.cpp	1970-01-01 00:00:00 +0000
+++ tests/plugins/bluetooth/tst_device.cpp	2014-07-31 14:30:31 +0000
@@ -0,0 +1,197 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QTest>
+#include <QSignalSpy>
+#include <QThread>
+
+#include "bluetooth.h"
+#include "device.h"
+#include "fakebluez.h"
+
+using namespace Bluez;
+
+class DeviceTest: public QObject
+{
+    Q_OBJECT
+
+private:
+    FakeBluez *m_bluezMock;
+    Device *m_device;
+    QDBusConnection *m_dbus;
+
+private:
+    void checkAudioState(const QString &expected);
+
+private Q_SLOTS:
+    void init();
+    void testGetName();
+    void testGetAddress();
+    void testGetIconName();
+    void testGetType();
+    void testIsPaired();
+    void testIsTrusted();
+    void testGetConnection();
+    void testGetStrength();
+    void testGetPath();
+    void testMakeTrusted();
+    void testDiscoverServices();
+    
+    void cleanup();
+
+};
+
+void DeviceTest::init()
+{
+    m_bluezMock = new FakeBluez();
+    m_bluezMock->addAdapter("new0", "bluetoothTest");
+    m_bluezMock->addDevice("My Phone", "00:00:de:ad:be:ef");
+    m_dbus = new QDBusConnection(m_bluezMock->dbus());
+
+    QList<QString> devices = m_bluezMock->devices();
+    if (devices.isEmpty())
+        QFAIL("No devices in mock to be tested.");
+
+    m_device = new Device(devices.first(), *m_dbus);
+}
+
+void DeviceTest::cleanup()
+{
+    delete m_bluezMock;
+    delete m_device;
+}
+
+void DeviceTest::testGetName()
+{
+    QCOMPARE(m_device->getName(), "My Phone");
+}
+
+void DeviceTest::testAddress()
+{
+    QCOMPARE(m_device->getAddress(), "00:00:de:ad:be:ef");
+}
+
+void DeviceTest::testIconName()
+{
+    QCOMPARE(m_device->getIconName(), "image://theme/audio-headset");
+}
+
+void DeviceTest::testGetType()
+{
+    QCOMPARE(m_device->getType(), Device::Type::Headset);
+}
+
+void DeviceTest::testIsPaired()
+{
+    QCOMPARE(m_device->isPaired(), false);
+
+    m_bluezMock->setProperty("org.bluez.Device", "Paired", QVariant(true));
+
+    QCOMPARE(m_device->isPaired(), true);
+}
+
+void DeviceTest::testIsTrusted()
+{
+    QCOMPARE(m_device->isTrusted(), false);
+
+    m_bluezMock->setProperty("org.bluez.Device", "Trusted", QVariant(true));
+
+    QCOMPARE(m_device->isTrusted(), true);
+}
+
+void DeviceTest::testGetConnection()
+{
+    QCOMPARE(m_device.getConnection(), Device::Connection::Disconnected);
+}
+
+void DeviceTest::testGetStrength()
+{
+    QCOMPARE(m_device.getStrength(), Device::Strength::Good);
+}
+
+void DeviceTest::testGetPath()
+{
+    QCOMPARE(m_device.getPath(),
+             "/org/bluez/" + m_bluezMock->currentAdapter() + "/"
+             + "dev_00_00_de_ad_be_ef");
+}
+
+void DeviceTest::testMakeTrusted()
+{
+    QCOMPARE(m_device->isTrusted(), false);
+
+    m_device->makeTrusted(true);
+
+    QCOMPARE(m_device->isTrusted(), true);
+
+    m_device->makeTrusted(false);
+
+    QCOMPARE(m_device->isTrusted(), false);
+}
+
+void DeviceTest::checkAudioState(const QString &expected)
+{
+    QVariant state = m_bluezMock->getProperty("org.bluez.Audio", "State");
+
+    QVERIFY(state.type() == QMetaType::QString);
+    QCOMPARE(state.toString(), expected);
+}
+
+void DeviceTest::testDiscoverServices()
+{
+    m_device->discoverServices();
+
+    QVariant state = m_bluezMock->getProperty("org.bluez.Audio", "State");
+
+    checkAudioState("disconnected");
+}
+
+void DeviceTest::testConnect()
+{
+    testDiscoverServices();
+
+    m_device->connect(Device::ConnectionMode::Audio);
+
+    checkAudioState("connected");
+}
+
+void DeviceTest::testDisconnect()
+{
+    testConnect();
+
+    m_device->disconnect(Device::ConnectionMode::Audio);
+
+    checkAudioState("disconnected");
+}
+
+void DeviceTest::testConnectPending()
+{
+    testIsPaired();
+    testIsTrusted();
+
+    m_device->addConnectAfterPairing(Device::ConnectionMode::Audio);
+
+    checkAudioState("disconnected");
+
+    m_device->connectPending();
+
+    checkAudioState("connected");
+}
+
+QTEST_MAIN(DeviceTest);
+#include "tst_device.moc"

=== added file 'tests/plugins/bluetooth/tst_devicemodel.cpp'
--- tests/plugins/bluetooth/tst_devicemodel.cpp	1970-01-01 00:00:00 +0000
+++ tests/plugins/bluetooth/tst_devicemodel.cpp	2014-07-31 14:30:31 +0000
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <QTest>
+#include <QSignalSpy>
+#include <QThread>
+
+#include "bluetooth.h"
+#include "devicemodel.h"
+#include "fakebluez.h"
+
+using namespace Bluez;
+
+class DeviceModelTest: public QObject
+{
+    Q_OBJECT
+
+private:
+    FakeBluez *m_bluezMock;
+    DeviceModel *m_devicemodel;
+    QDBusConnection *m_dbus;
+
+private Q_SLOTS:
+    void init();
+    void testDeviceFoundOnStart();
+    void testDeviceFound();
+    void testGetDeviceFromAddress();
+    void testGetDeviceFromPath();
+    void cleanup();
+
+};
+
+void DeviceModelTest::init()
+{
+    m_bluezMock = new FakeBluez();
+
+    m_bluezMock->addAdapter("new0", "bluetoothTest");
+    m_bluezMock->addDevice("My Phone", "00:00:de:ad:be:ef");
+
+    m_dbus = new QDBusConnection(m_bluezMock->dbus());
+    m_devicemodel = new DeviceModel(*m_dbus);
+}
+
+void DeviceModelTest::cleanup()
+{
+    delete m_bluezMock;
+    delete m_devicemodel;
+}
+
+void DeviceModelTest::testDeviceFoundOnStart()
+{
+    QCOMPARE(m_devicemodel->rowCount(), 1);
+}
+
+void DeviceModelTest::testDeviceFound()
+{
+    QSKIP("TODO: Finish me.", SkipAll);
+
+    m_bluezMock->addDevice("My New Phone", "00:0b:ad:c0:ff:ee");
+    QCOMPARE(m_devicemodel->rowCount(), 2);
+}
+
+void DeviceModelTest::testGetDeviceFromAddress()
+{
+    auto device = m_devicemodel->getDeviceFromAddress("00:00:de:ad:be:ef");
+
+    QVERIFY(device);
+    QVERIFY(!device->getPath().isEmpty());
+}
+
+void DeviceModelTest::testGetDeviceFromPath()
+{
+    QList<QString> devices = m_bluezMock->devices();
+
+    auto device = m_devicemodel->getDeviceFromPath(devices.at(0));
+
+    QVERIFY(device);
+    QVERIFY(!device->getPath().isEmpty());
+}
+
+QTEST_MAIN(DeviceModelTest);
+#include "tst_devicemodel.moc"