Merge lp:~michael-sheldon/content-hub/peer_picker_ui into lp:content-hub

[Michael Sheldon]

Implements the new QML API for content hub, including the addition of the Peer Picker UI element. These changes are still in progress, the merge request is currently for tracking purposes.

Implements the new QML API for content hub, including the addition of the Peer Picker UI element. These changes are still in progress, the merge request is currently for tracking purposes.

[Bill Filler (bfiller)]

set status to Needs Review in hopes to get CI to build it

[lp:~michael-sheldon/content-hub/peer_picker_ui]

151. By Michael Sheldon on 2014-03-18

Make it possible to use an external ContentPeerModel in the ContentPeerPicker via a Loader

152. By Michael Sheldon on 2014-03-19

Merge changes from trunk

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:152
http://jenkins.qa.ubuntu.com/job/content-hub-ci/128/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/content-hub-trusty-amd64-ci/31
    SUCCESS: http://jenkins.qa.ubuntu.com/job/content-hub-trusty-armhf-ci/31
        deb: http://jenkins.qa.ubuntu.com/job/content-hub-trusty-armhf-ci/31/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/content-hub-trusty-i386-ci/31

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/content-hub-ci/128/rebuild

review: Approve (continuous-integration)

[lp:~michael-sheldon/content-hub/peer_picker_ui]

153. By Michael Sheldon on 2014-03-20

Add documentation to ContentTransferHint and ContentPeerPicker elements

154. By Michael Sheldon on 2014-03-20

Update documentation

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:154
http://jenkins.qa.ubuntu.com/job/content-hub-ci/129/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/content-hub-trusty-amd64-ci/32
    SUCCESS: http://jenkins.qa.ubuntu.com/job/content-hub-trusty-armhf-ci/32
        deb: http://jenkins.qa.ubuntu.com/job/content-hub-trusty-armhf-ci/32/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/content-hub-trusty-i386-ci/32

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/content-hub-ci/129/rebuild

review: Approve (continuous-integration)

[Michael Sheldon (michael-sheldon)]

Are there any related MPs required for this MP to build/function as expected? Please list.

 The following MRs are required to make the Gallery, Address Book and System Settings apps compatible with the new API:

 * https://code.launchpad.net/~ken-vandine/gallery-app/content_hub/+merge/211091
 * https://code.launchpad.net/~michael-sheldon/address-book-app/new-content-hub-api/+merge/211093
 * https://code.launchpad.net/~ken-vandine/ubuntu-system-settings/content_hub_qml_api_changes/+merge/211094

Is your branch in sync with latest trunk (e.g. bzr pull lp:trunk -> no changes)

 * Yes

Did you perform an exploratory manual test run of your code change and any related functionality on device or emulator?

 * Yes

Did you successfully run all tests found in your component's Test Plan (https://wiki.ubuntu.com/Process/Merges/TestPlan/content-hub) on device or emulator?

 * Yes

If you changed the UI, was the change specified/approved by design?

 * Yes, Peer Picker UI component implemented based upon specification here: https://docs.google.com/a/canonical.com/document/d/1trse15NokU8IJ5lm3BnUi7oMNTCkUnYNHeAHZdtzFoQ

If you changed the packaging (debian), did you subscribe a core-dev to this MP?

 * No packaging changes.

[Ken VanDine (ken-vandine)]

Did you perform an exploratory manual test run of the code change and any related functionality on device or emulator?

 * Yes, as per: https://wiki.ubuntu.com/Process/Merges/TestPlan/content-hub with
   - gallery-app from lp:~ken-vandine/gallery-app/content_hub/ (r926)
   - address-book-app from lp:~michael-sheldon/address-book-app/new-content-hub-api (r149)
   - ubuntu-system-settings from lp:~ken-vandine/ubuntu-system-settings/content_hub_qml_api_changes (r639)

Did CI run pass? If not, please explain why.

 * Yes

Have you checked that submitter has accurately filled out the submitter checklist and has taken no shortcut?

 * Yes

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-12-06 12:33:14 +0000
+++ CMakeLists.txt	2014-03-20 13:33:31 +0000
@@ -34,6 +34,8 @@
   set(CMAKE_INSTALL_FULL_LIBEXECDIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBEXECDIR}")
 endif()
 
+set(pkglibexecdir "${CMAKE_INSTALL_FULL_LIBEXECDIR}")
+
 
 #####################################################################
 # Enable code coverage calculation with gcov/gcovr/lcov
@@ -63,6 +65,7 @@
 pkg_check_modules(GSETTINGS REQUIRED gsettings-qt)
 pkg_check_modules(NIH REQUIRED libnih)
 pkg_check_modules(NIH_DBUS REQUIRED libnih-dbus)
+pkg_check_modules(DBUS REQUIRED dbus-1)
 
 set(CONTENT_HUB_VERSION_MAJOR 0)
 set(CONTENT_HUB_VERSION_MINOR 0)

=== modified file 'doc/qml/pages/mainpage.qdoc'
--- doc/qml/pages/mainpage.qdoc	2013-10-22 20:06:33 +0000
+++ doc/qml/pages/mainpage.qdoc	2014-03-20 13:33:31 +0000
@@ -72,28 +72,45 @@
 
 Rectangle {
   id: root
-  Button {
-      text: "Import from default"
-       onClicked: {
-           var peer = ContentHub.defaultSourceForType(ContentType.Pictures);
-           activeTransfer = ContentHub.importContent(ContentType.Pictures, peer);
-      }
-  }
-  Button {
-      text: "Import from a selectable list"
-       onClicked: {
-           activeTransfer = ContentHub.importContent(ContentType.Pictures);
-           activeTransfer.selectionType =ContentTransfer.Multiple;
-           activeTransfer.start();
-      }
-  }
-  ContentImportHint {
-      id: importHint
+  property list<ContentItem> importItems
+  property var activeTransfer
+
+  ContentPeer {
+      id: picSourceSingle
+      contentType: ContentType.Pictures
+      handler: ContentHandler.Source
+      selectionType: ContentTransfer.Single
+  }
+
+  ContentPeer {
+      id: picSourceMulti
+      contentType: ContentType.Pictures
+      handler: ContentHandler.Source
+      selectionType: ContentTransfer.Multiple
+  }
+
+  Row {
+      Button {
+          text: "Import single item"
+          onClicked: {
+              activeTransfer = picSourceSingle.request()
+          }
+      }
+
+      Button {
+          text: "Import multiple items"
+          onClicked: {
+              activeTransfer = picSourceMulti.request()
+          }
+      }
+  }
+
+  ContentTransferHint {
+      id: transferHint
       anchors.fill: parent
       activeTransfer: root.activeTransfer
   }
-  property list<ContentItem> importItems
-  property var activeTransfer
+
   Connections {
       target: root.activeTransfer
       onStateChanged: {
@@ -107,8 +124,12 @@
 \part General Topics
 \list
     \li \l {ContentHub}
+    \li \l {ContentPeer}
+    \li \l {ContentPeerModel}
+    \li \l {ContentPeerPicker}
+    \li \l {ContentStore}
     \li \l {ContentTransfer}
-    \li \l {ContentImportHint}
+    \li \l {ContentTransferHint}
     \li \l {ContentType}
 \endlist
 

=== added file 'examples/export-qml/app-exporter.qml'
--- examples/export-qml/app-exporter.qml	1970-01-01 00:00:00 +0000
+++ examples/export-qml/app-exporter.qml	2014-03-20 13:33:31 +0000
@@ -0,0 +1,216 @@
+import QtQuick 2.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.Popups 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+import Ubuntu.Content 0.1
+
+MainView {
+    id: root
+    applicationName: "app-exporter"
+    width: units.gu(50)
+    height: units.gu(60)
+
+    property bool pickMode: activeTransfer.state === ContentTransfer.InProgress
+    property var selectedItems: []
+    property var activeTransfer
+
+    ListModel {
+        id: images
+
+        ListElement {
+            src: "file:///usr/share/icons/hicolor/128x128/apps/ubuntuone-music.png"
+        }
+
+        ListElement {
+            src: "file:///usr/share/icons/hicolor/128x128/apps/ubuntuone-music.png"
+        }
+
+        ListElement {
+            src: "file:///usr/share/icons/hicolor/128x128/apps/ubuntuone-music.png"
+        }
+
+        ListElement {
+            src: "file:///usr/share/icons/hicolor/128x128/apps/ubuntuone-music.png"
+        }
+    }
+
+    GridView {
+        anchors.fill: parent
+        model: images
+        cellWidth: 128
+        cellHeight: 128
+        delegate: itemDelegate
+    }
+
+    Component {
+        id: resultComponent
+        ContentItem {}
+    }
+
+    Component {
+        id: itemDelegate
+        Item {
+            width: 128
+            height: 128
+
+            property bool isSelected: false
+
+            UbuntuShape {
+                width: parent.width
+                height: width
+                image: Image {
+                    id: image
+                    source: src
+                    height: parent.width
+                    width: height
+                    fillMode: Image.PreserveAspectFit
+                    smooth: true
+                }
+
+                MouseArea {
+                    anchors.fill: parent
+                    enabled: pickMode
+                    onClicked: {
+                        var shouldAdd = true;
+                        for (var i = 0; i < selectedItems.length; i++)
+                        {
+                            console.log("item: ", selectedItems[i]);
+                            if (selectedItems[i] === src)
+                            {
+                                selectedItems.pop(i);
+                                shouldAdd = false;
+                                isSelected = false;
+                            }
+                        }
+                        if (shouldAdd)
+                        {
+                            selectedItems.push(src);
+                            isSelected = true;
+                        }
+                    }
+                }
+
+                Image {
+                    id: selectionTick
+                    anchors.right: parent.right
+                    anchors.top: parent.top
+                    width: units.gu(5)
+                    height: units.gu(5)
+                    visible: isSelected
+                    source: "photo-preview-selected-overlay.png"
+                }
+
+                MouseArea {
+                    anchors.fill: parent
+                    enabled: !pickMode
+                    onClicked: {
+                        actPop.show();
+                    }
+                }
+
+                ActionSelectionPopover {
+                    id: actPop
+                    delegate: ListItem.Standard {
+                      text: action.text
+                    }
+
+                    contentWidth: childrenRect.width
+
+                    actions: ActionList {
+                        Action {
+                            text: "Open with..."
+                            onTriggered: {
+                                print(text + ": " + src);
+                                activeTransfer = picDest.request();
+                                activeTransfer.items = [ resultComponent.createObject(root, {"url": src}) ];
+                                activeTransfer.state = ContentTransfer.Charged;
+                                actPop.hide();
+                            }
+                        }
+                        Action {
+                            text: "Share"
+                            onTriggered: {
+                                print(text + ": " + src);
+                                activeTransfer = picShare.request();
+                                activeTransfer.items = [ resultComponent.createObject(root, {"url": src}) ];
+                                activeTransfer.state = ContentTransfer.Charged;
+                                actPop.hide();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    ContentPeer {
+        id: picDest
+        // well know content type
+        contentType: ContentType.Pictures
+        // Type of handler: Source, Destination, or Share
+        handler: ContentHandler.Destination
+        // Optional appId, if this isn't specified the hub will use the default
+        //appId: ""
+    }
+
+    ContentPeer {
+        id: picShare
+        // well know content type
+        contentType: ContentType.Pictures
+        // Type of handler: Source, Destination, or Share
+        handler: ContentHandler.Share
+        // Optional appId, if this isn't specified the hub will use the default
+        appId: "pkg_app_version"
+    }
+
+    // Provides overlay showing another app is being used to complete the request
+    // formerly named ContentImportHint
+    ContentTransferHint {
+        anchors.fill: parent
+        activeTransfer: activeTransfer
+    }
+
+    Connections {
+        target: ContentHub
+        onExportRequested: {
+            activeTransfer = transfer
+        }
+    }
+
+    ListItem.Empty {
+        id: pickerButtons
+        anchors {
+            left: parent.left
+            right: parent.right
+            bottom: parent.bottom
+            margins: units.gu(2)
+        }
+        visible: pickMode
+        Button {
+            anchors {
+                left: parent.left
+                bottom: parent.bottom
+                margins: units.gu(2)
+            }
+            text: "Cancel"
+            onClicked: activeTransfer.state = ContentTransfer.Aborted;
+        }
+
+        Button {
+            anchors {
+                right: parent.right
+                bottom: parent.bottom
+                margins: units.gu(2)
+            }
+            text: "Select"
+            onClicked: {
+                var results = [];
+                for (var i = 0; i < selectedItems.length; i++)
+                    results.push(resultComponent.createObject(root, {"url": selectedItems[i]}));
+
+                if (results.length > 0)
+                    activeTransfer.items = results;
+            }
+        }
+    }
+}

=== modified file 'examples/export-qml/export.qml'
--- examples/export-qml/export.qml	2013-08-26 17:36:58 +0000
+++ examples/export-qml/export.qml	2014-03-20 13:33:31 +0000
@@ -2,20 +2,15 @@
 import Ubuntu.Components 0.1
 import Ubuntu.Content 0.1
 
-Rectangle {
+MainView {
     id: root
     width: 300
     height: 200
 
-    property bool pickMode: false
+    property bool pickMode: activeTransfer.state === ContentTransfer.InProgress
     property list<ContentItem> selectedItems
     property var activeTransfer
 
-    function __returnResult() {
-        activeTransfer.items = selectedItems;
-        activeTransfer.state = ContentTransfer.Charged;
-    }
-
     Button {
         id: button1
         anchors.top: parent.top
@@ -23,12 +18,11 @@
         enabled: pickMode
         text: "Return URL1"
         onClicked: {
-            var result = resultComponent.createObject(root);
-            result.url = "file:///picture_1.jpg";
-            selectedItems = [ result ];
-            root.__returnResult();
+            selectedItems = [ resultComponent.createObject(root, {"url": "file:///picture_1.jpg"}) ];
+            activeTransfer.items = selectedItems;
         }
     }
+
     Button {
         id: button2
         anchors.top: parent.top
@@ -36,19 +30,10 @@
         enabled: pickMode
         text: "Return Url2"
         onClicked: {
-            var results = [];
-
-            var result = resultComponent.createObject(root);
-            result.url = "file:///picture_1.jpg";
-            results.push(result);
-
-            result = resultComponent.createObject(root);
-            result.url = "file:///picture_2.jpg";
-            results.push(result);
-
-            selectedItems = results;
+            selectedItems.push(resultComponent.createObject(root, {"url": "file:///picture_1.jpg"}));
+            selectedItems.push(resultComponent.createObject(root, {"url": "file:///picture_2.jpg"}));
             console.log(selectedItems[0].url + "/" + selectedItems[1].url)
-            root.__returnResult();
+            activeTransfer.items = selectedItems;
         }
     }
 
@@ -59,8 +44,7 @@
         enabled: pickMode
         text: "Cancel"
         onClicked: {
-            root.activeTransfer.state = ContentTransfer.Aborted;
-            root.pickMode = false;
+            activeTransfer.state = ContentTransfer.Aborted;
         }
     }
 
@@ -72,8 +56,7 @@
     Connections {
         target: ContentHub
         onExportRequested: {
-            root.activeTransfer = transfer
-            root.pickMode = true;
+            activeTransfer = transfer
         }
     }
 }

=== added file 'examples/export-qml/photo-preview-selected-overlay.png'
Binary files examples/export-qml/photo-preview-selected-overlay.png	1970-01-01 00:00:00 +0000 and examples/export-qml/photo-preview-selected-overlay.png	2014-03-20 13:33:31 +0000 differ
=== modified file 'examples/exporter/CMakeLists.txt'
--- examples/exporter/CMakeLists.txt	2013-08-28 18:22:37 +0000
+++ examples/exporter/CMakeLists.txt	2014-03-20 13:33:31 +0000
@@ -23,7 +23,7 @@
   exampleexporter.cpp
 )
 
-qt5_use_modules(exporter Core)
+qt5_use_modules(exporter Core Gui DBus)
 
 set_target_properties(
   exporter

=== modified file 'examples/exporter/exampleexporter.cpp'
--- examples/exporter/exampleexporter.cpp	2013-09-05 18:49:34 +0000
+++ examples/exporter/exampleexporter.cpp	2014-03-20 13:33:31 +0000
@@ -24,6 +24,12 @@
     hub->register_import_export_handler(this);
 }
 
+void ExampleExporter::handle_import(cuc::Transfer *transfer)
+{
+    qDebug() << Q_FUNC_INFO << "not implemented";
+    Q_UNUSED(transfer);
+}
+
 void ExampleExporter::handle_export(cuc::Transfer *transfer)
 {
     qDebug() << Q_FUNC_INFO;
@@ -45,7 +51,7 @@
     qDebug() << Q_FUNC_INFO << "Items:" << items.count();
 }
 
-void ExampleExporter::handle_import(cuc::Transfer *transfer)
+void ExampleExporter::handle_share(cuc::Transfer *transfer)
 {
     qDebug() << Q_FUNC_INFO << "not implemented";
     Q_UNUSED(transfer);

=== modified file 'examples/exporter/exampleexporter.h'
--- examples/exporter/exampleexporter.h	2013-08-29 15:51:28 +0000
+++ examples/exporter/exampleexporter.h	2014-03-20 13:33:31 +0000
@@ -37,7 +37,7 @@
 public slots:
     Q_INVOKABLE void handle_import(cuc::Transfer*);
     Q_INVOKABLE void handle_export(cuc::Transfer*);
-    
+    Q_INVOKABLE void handle_share(cuc::Transfer*);
 };
 
 #endif // EXAMPLEEXPORTER_H

=== modified file 'examples/exporter/exporter.cpp'
--- examples/exporter/exporter.cpp	2013-08-29 15:51:28 +0000
+++ examples/exporter/exporter.cpp	2014-03-20 13:33:31 +0000
@@ -17,6 +17,8 @@
  */
 
 #include <QCoreApplication>
+#include <QStringList>
+
 
 #include "exampleexporter.h"
 
@@ -31,5 +33,21 @@
 
     ExampleExporter exporter;
 
+    QString peerName;
+
+    if (a.arguments().size() > 1)
+        peerName = a.arguments().at(1);
+
+    if (!peerName.isEmpty())
+    {
+        qDebug() << peerName;
+        auto hub = cuc::Hub::Client::instance();
+
+        auto peer = cuc::Peer{peerName};
+        qDebug() << Q_FUNC_INFO << "PEER: " << peer.id();
+        auto transfer = hub->create_export_to_peer(peer);
+        exporter.handle_export(transfer);
+    }
+
     return a.exec();
 }

=== modified file 'examples/import-qml/import.qml'
--- examples/import-qml/import.qml	2013-11-08 21:04:52 +0000
+++ examples/import-qml/import.qml	2014-03-20 13:33:31 +0000
@@ -1,7 +1,6 @@
 import QtQuick 2.0
 import Ubuntu.Components 0.1
 import Ubuntu.Components.ListItems 0.1 as ListItem
-
 import Ubuntu.Content 0.1
 
 MainView {
@@ -12,26 +11,31 @@
 
     property list<ContentItem> importItems
     property var activeTransfer
-    property list<ContentPeer> peers
-
-
-    function _importFromPeer(peer) {
-        /* if peer is null, choose default */
-        if (peer === null)
-            peer = ContentHub.defaultSourceForType(ContentType.Pictures);
-        var transfer = ContentHub.importContent(ContentType.Pictures, peer);
-        var store = ContentHub.defaultStoreForType(ContentType.Pictures);
-        console.log("Store is: " + store.uri);
-        if (transfer !== null) {
-            transfer.selectionType = ContentTransfer.Multiple;
-            transfer.setStore(store);
-            activeTransfer = transfer;
-            activeTransfer.start();
-        }
-    }
-
-    Component.onCompleted: {
-        peers = ContentHub.knownSourcesForType(ContentType.Pictures);
+
+
+    ContentPeer {
+        id: picSource
+        // well know content type
+        contentType: ContentType.Pictures
+        // Type of handler: Source, Destination, or Share
+        handler: ContentHandler.Source
+        // Optional appId, if this isn't specified the hub will use the default
+        //appId: ""
+    }
+        
+    // Optional store to use for persistent storage of content
+    ContentStore {
+        id: appStore
+        scope: ContentScope.App
+    }
+
+    // Provides a list<ContentPeer> suitable for use as a model
+    ContentPeerModel {
+        id: picSources
+        // Type of handler: Source, Destination, or Share
+        handler: ContentHandler.Source
+        // well know content type
+        contentType: ContentType.Pictures
     }
 
     ListView {
@@ -42,14 +46,15 @@
             top: importButtons.bottom
         }
         height: childrenRect.height
-        model: peers
+        model: picSources.peers
 
         delegate: ListItem.Standard {
             text: modelData.name
             control: Button {
                 text: "Import"
                 onClicked: {
-                    _importFromPeer(modelData);
+                    // Request the transfer, it needs to be created and dispatched from the hub
+                    activeTransfer = modelData.request();
                 }
             }
         }
@@ -64,7 +69,9 @@
             }
             text: "Import from default"
             onClicked: {
-                _importFromPeer(null);
+                // Request the transfer, it needs to be created and dispatched from the hub
+                // Specify a location to use for permanent storage
+                activeTransfer = picSource.request(appStore);
             }
         }
 
@@ -79,7 +86,6 @@
         }
     }
 
-
     ListView {
         id: resultList
         anchors {
@@ -108,13 +114,15 @@
             }
     }
 
-    ContentImportHint {
+    // Provides overlay showing another app is being used to complete the request
+    // formerly named ContentImportHint
+    ContentTransferHint {
         anchors.fill: parent
-        activeTransfer: root.activeTransfer
+        activeTransfer: activeTransfer
     }
 
     Connections {
-        target: root.activeTransfer
+        target: activeTransfer
         onStateChanged: {
             console.log("StateChanged: " + activeTransfer.state);
             if (activeTransfer.state === ContentTransfer.Charged)

=== modified file 'examples/importer/CMakeLists.txt'
--- examples/importer/CMakeLists.txt	2013-08-28 18:22:37 +0000
+++ examples/importer/CMakeLists.txt	2014-03-20 13:33:31 +0000
@@ -24,7 +24,7 @@
   example.cpp
 )
 
-qt5_use_modules(importer Core)
+qt5_use_modules(importer Core Gui DBus)
 
 set_target_properties(
   importer

=== modified file 'examples/importer/example.cpp'
--- examples/importer/example.cpp	2013-10-01 16:55:39 +0000
+++ examples/importer/example.cpp	2014-03-20 13:33:31 +0000
@@ -30,12 +30,11 @@
 {
     auto hub = cuc::Hub::Client::instance();
 
-    auto peer = hub->default_peer_for_type(cuc::Type::Known::pictures());
+    auto peer = hub->default_source_for_type(cuc::Type::Known::pictures());
+
     qDebug() << Q_FUNC_INFO << "PEER: " << peer.name();
 
-    m_transfer = hub->create_import_for_type_from_peer(
-        cuc::Type::Known::pictures(),
-        peer);
+    m_transfer = hub->create_import_from_peer(peer);
 
     /* Uncommit this for persistent storage
     auto store = hub->store_for_scope_and_type(cuc::Scope::app, cuc::Type::Known::pictures());

=== modified file 'examples/importer/exampleimporter.cpp'
--- examples/importer/exampleimporter.cpp	2013-10-01 16:55:39 +0000
+++ examples/importer/exampleimporter.cpp	2014-03-20 13:33:31 +0000
@@ -25,11 +25,6 @@
     hub->register_import_export_handler(this);
 }
 
-void ExampleImporter::handle_export(cuc::Transfer *transfer)
-{
-    qDebug() << Q_FUNC_INFO << "not implemented";
-    Q_UNUSED(transfer);
-}
 
 void ExampleImporter::handle_import(cuc::Transfer *transfer)
 {
@@ -40,3 +35,15 @@
         qDebug() << Q_FUNC_INFO << "Item:" << item.url();
     transfer->finalize();
 }
+
+void ExampleImporter::handle_export(cuc::Transfer *transfer)
+{
+    qDebug() << Q_FUNC_INFO << "not implemented";
+    Q_UNUSED(transfer);
+}
+
+void ExampleImporter::handle_share(cuc::Transfer *transfer)
+{
+    qDebug() << Q_FUNC_INFO << "not implemented";
+    Q_UNUSED(transfer);
+}

=== modified file 'examples/importer/exampleimporter.h'
--- examples/importer/exampleimporter.h	2013-08-28 18:22:37 +0000
+++ examples/importer/exampleimporter.h	2014-03-20 13:33:31 +0000
@@ -34,6 +34,7 @@
     ExampleImporter();
     Q_INVOKABLE void handle_import(cuc::Transfer*);
     Q_INVOKABLE void handle_export(cuc::Transfer*);    
+    Q_INVOKABLE void handle_share(cuc::Transfer*);
 };
 
 #endif // EXAMPLEIMPORTER_H

=== modified file 'examples/importer/importer.cpp'
--- examples/importer/importer.cpp	2013-08-20 16:21:15 +0000
+++ examples/importer/importer.cpp	2014-03-20 13:33:31 +0000
@@ -17,6 +17,7 @@
  */
 
 #include <QCoreApplication>
+#include <QStringList>
 #include "example.h"
 
 namespace cuc = com::ubuntu::content;
@@ -27,7 +28,23 @@
 
     Example *e = new Example();
 
-    e->create_import();
+    QString peerName;
+
+    if (a.arguments().size() > 1)
+        peerName = a.arguments().at(1);
+
+    if (!peerName.isEmpty())
+    {
+        qDebug() << peerName;
+        auto hub = cuc::Hub::Client::instance();
+
+        auto peer = cuc::Peer{peerName};
+        qDebug() << Q_FUNC_INFO << "PEER: " << peer.id();
+        auto transfer = hub->create_import_from_peer(peer);
+        transfer->start();
+    }
+
+    Q_UNUSED(e);
 
     return a.exec();
 }

=== added directory 'examples/picker-qml'
=== added file 'examples/picker-qml/picker.qml'
--- examples/picker-qml/picker.qml	1970-01-01 00:00:00 +0000
+++ examples/picker-qml/picker.qml	2014-03-20 13:33:31 +0000
@@ -0,0 +1,127 @@
+import QtQuick 2.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+import Ubuntu.Components.Popups 0.1
+
+import Ubuntu.Content 0.1
+
+MainView {
+    id: mainView
+    applicationName: "picker-qml"
+
+    width: units.gu(100)
+    height: units.gu(75)
+
+    PageStack {
+        id: pageStack
+        Component.onCompleted: pageStack.push(root)
+
+        Page {
+            id: root
+            title: i18n.tr("Peer Picker Example")
+            visible: false
+
+            property list<ContentItem> importItems
+            property var activeTransfer
+            property list<ContentPeer> peers
+
+            Column {
+                anchors.fill: parent
+
+                ListItem.Standard {
+                    id: peerListHeader
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                    }
+                    text: i18n.tr("Sources")
+                    control: Button {
+                        text: i18n.tr("Select source")
+                        onClicked: {
+                            pageStack.push(picker);
+                        }
+                    }
+                }
+
+                ListItem.Header {
+                    id: titleItem
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                    }
+                    text: i18n.tr("Results")
+                }
+
+                GridView {
+                    id: resultList
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                    }
+                    height: childrenRect.height
+                    cellWidth: units.gu(20)
+                    cellHeight: cellWidth
+
+                    model: root.importItems
+                    delegate: Item {
+                        id: result
+                        height: units.gu(19)
+                        width: height
+                        UbuntuShape {
+                            width: parent.width
+                            height: width
+                            image: Image {
+                                id: image
+                                source: url
+                                sourceSize.width: width
+                                sourceSize.height: height
+                                height: parent.height
+                                width: height
+                                fillMode: Image.PreserveAspectFit
+                                smooth: true
+                            }
+                        }
+                    }
+                }
+            }
+
+            ContentTransferHint {
+                anchors.fill: root
+                activeTransfer: root.activeTransfer
+            }
+
+            Connections {
+                target: root.activeTransfer
+                onStateChanged: {
+                    console.log("StateChanged: " + root.activeTransfer.state);
+                    if (root.activeTransfer.state === ContentTransfer.Charged)
+                        root.importItems = root.activeTransfer.items;
+                }
+            }
+
+        }
+
+        Page {
+            id: picker
+            visible: false
+
+            ContentPeerPicker {
+                visible: parent.visible
+
+                // Type of handler: Source, Destination, or Share
+                handler: ContentHandler.Source
+                // well know content type
+                contentType: ContentType.Pictures
+
+                onPeerSelected: {
+                    root.activeTransfer = peer.request();
+                    pageStack.pop();
+                }
+
+                onCancelPressed: {
+                    pageStack.pop();
+                }
+            }
+        }
+    }
+}

=== modified file 'import/Ubuntu/Content/CMakeLists.txt'
--- import/Ubuntu/Content/CMakeLists.txt	2013-10-01 16:55:39 +0000
+++ import/Ubuntu/Content/CMakeLists.txt	2014-03-20 13:33:31 +0000
@@ -26,13 +26,24 @@
 
 set(PLUGIN ubuntu-content-hub-plugin)
 
-include_directories(${CMAKE_SOURCE_DIR})
+add_definitions(-DQT_NO_KEYWORDS)
+
+include_directories(
+    ${CMAKE_SOURCE_DIR}
+    ${NIH_INCLUDE_DIRS}
+    ${NIH_DBUS_INCLUDE_DIRS}
+    ${DBUS_INCLUDE_DIRS}
+)
 
 set(PLUGIN_HDRS
+    contenthandler.h
     contenthub.h
     contenthubplugin.h
+    contenticonprovider.h
     contentitem.h
     contentpeer.h
+    contentpeermodel.h
+    contentscope.h
     contentstore.h
     contenttransfer.h
     contenttype.h
@@ -40,10 +51,14 @@
     )
 
 set(PLUGIN_SRC
+    contenthandler.cpp
     contenthub.cpp
     contenthubplugin.cpp
+    contenticonprovider.cpp
     contentitem.cpp
     contentpeer.cpp
+    contentpeermodel.cpp
+    contentscope.cpp
     contentstore.cpp
     contenttransfer.cpp
     contenttype.cpp
@@ -52,8 +67,13 @@
 
 add_library(${PLUGIN} MODULE ${PLUGIN_SRC} ${PLUGIN_HDRS})
 
-qt5_use_modules(${PLUGIN} Core Qml Quick)
-target_link_libraries(${PLUGIN} content-hub)
+qt5_use_modules(${PLUGIN} Core Qml Quick DBus)
+target_link_libraries(
+    ${PLUGIN}
+    content-hub
+    ${NIH_LIBRARIES}
+    ${NIH_DBUS_LIBRARIES}
+)
 
 install(TARGETS ${PLUGIN} DESTINATION ${CONTENT_HUB_IMPORTS_DIR})
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/qmldir DESTINATION ${CONTENT_HUB_IMPORTS_DIR})

=== added file 'import/Ubuntu/Content/ContentPeerPicker.qml'
--- import/Ubuntu/Content/ContentPeerPicker.qml	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/ContentPeerPicker.qml	2014-03-20 13:33:31 +0000
@@ -0,0 +1,260 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.Popups 0.1
+import Ubuntu.Components.ListItems 0.1 as ListItem
+import Ubuntu.Content 0.1
+
+/*!
+    \qmltype ContentPeerPicker
+    \inqmlmodule Ubuntu.Content 0.1
+    \brief Component that allows users to select a source/destination for content transfer
+
+    This component displays a list of applications, devices and services which
+    are appropriate for transferring a given content type with.
+*/
+Item {
+    id: root
+    anchors.fill: parent
+    visible: false
+
+    /*!
+        \qmlproperty ContentHandler handler
+        \brief The ContentHandler to use when finding peers.
+    */
+    property var handler
+
+    /*! \qmlproperty ContentType contentType
+        \brief The ContentType to use when finding peers.
+    */
+    property var contentType
+
+    /*! \qmlproperty bool showTitle
+        \brief Determines whether the header should be displayed.
+
+        This makes it possible to hide the header, which can be useful
+        if embedding the picker within another page or popup.
+    */
+    property alias showTitle: header.visible
+
+    /*! \qmlproperty ContentPeer peer
+        \brief The peer selected by the user.
+
+        Once the peerSelected signal has been sent, this provides the
+        ContentPeer which the user has selected.
+    */
+    property var peer
+
+    /*! \qmlproperty Loader customerPeerModelLoader
+        \brief A Loader containing a ContentPeerModel.
+
+        This can optionally be used to provide a pre-populated ContentPeerModel
+        to this ContentPeerPicker.
+    */
+    property var customPeerModelLoader
+
+    /*! \qmlsignal peerSelected
+        \brief Emitted when a user selects a peer.
+
+        Once this signal has been emitted the selected peer can be accessed via
+        the peer property.
+        \c onPeerSelected
+    */
+    signal peerSelected
+
+    /*! \qmlsignal cancelPressed
+        \brief Emitted when the user clicks the cancel button.
+        
+        The ContentPeerPicker will be hidden automatically when the user cancels
+        the operations and the active ContentTransfer will be set to Aborted.
+        \c onCancelPressed
+    */
+    signal cancelPressed
+
+    Header {
+        id: header
+        title: (handler === ContentHandler.Source) ? i18n.tr("Choose from") : i18n.tr("Share to")
+    }
+
+    Loader {
+        id: peerModelLoader
+        active: false
+        sourceComponent: ContentPeerModel {
+            id: peerModel
+        }
+        onLoaded: {
+            item.handler = root.handler
+            item.contentType = root.contentType
+        }
+    }
+
+    Component.onCompleted: {
+        if(customPeerModelLoader) {
+            customPeerModelLoader.active = true;
+        } else {
+            peerModelLoader.active = true;
+        }
+    }
+
+    Component {
+        id: peerDelegate
+        Item {
+            width: units.gu(13.5)
+            height: units.gu(16)
+            AbstractButton {
+                width: parent.width
+                height: icon.height + label.height
+                UbuntuShape {
+                    id: icon
+                    anchors {
+                        top: parent.top
+                        horizontalCenter: parent.horizontalCenter
+                    }
+                    radius: "medium"
+                    width: units.gu(8)
+                    height: units.gu(7.5)
+                    image: Image {
+                        id: image
+                        objectName: "image"
+                        sourceSize { width: icon.width; height: icon.height }
+                        asynchronous: true
+                        cache: false
+                        source: "image://content-hub/" + modelData.appId
+                        horizontalAlignment: Image.AlignHCenter
+                        verticalAlignment: Image.AlignVCenter
+                    }
+               }
+
+                Label {
+                    id: label
+                    objectName: "label"
+                    anchors {
+                        baseline: icon.bottom
+                        baselineOffset: units.gu(2)
+                        left: parent.left
+                        right: parent.right
+                        leftMargin: units.gu(1)
+                        rightMargin: units.gu(1)
+                    }
+
+                    opacity: 0.9
+                    fontSize: "small"
+                    elide: Text.ElideMiddle
+                    horizontalAlignment: Text.AlignHCenter
+                    text: modelData.name || modelData.appId
+                }
+
+                onClicked: {
+                        peer = modelData
+                        peerSelected()
+                }
+            }
+
+        }
+    }
+
+    ListItem.Header {
+        id: appTitle
+        anchors.top: header.visible ? header.bottom : parent.top
+        text: "Apps"
+    }
+
+    Rectangle {
+        id: apps
+        color: "#FFFFFF"
+        height: (parent.height / 2.4)
+        width: parent.width
+        clip: true
+        anchors {
+            left: parent.left
+            right: parent.right
+            top: appTitle.bottom
+        }
+
+        Flickable {
+            anchors.fill: parent
+
+            ResponsiveGridView {
+                id: appPeers
+                anchors.fill: parent
+                minimumHorizontalSpacing: units.gu(0.5)
+                maximumNumberOfColumns: 6
+                delegateWidth: units.gu(11)
+                delegateHeight: units.gu(9.5)
+                verticalSpacing: units.gu(2)
+                model: customPeerModelLoader ? customPeerModelLoader.item.peers : peerModelLoader.item.peers
+                delegate: peerDelegate
+            }
+
+        }
+    }
+
+    ListItem.Header {
+        id: devTitle
+        anchors {
+            left: parent.left
+            right: parent.right
+            top: apps.bottom
+        }
+        text: "Devices"
+    }
+
+    Rectangle {
+        id: devices
+        color: "#FFFFFF"
+        width: parent.width
+        radius: 0
+        anchors {
+            left: parent.left
+            right: parent.right
+            top: devTitle.bottom
+            bottom: cancelButton.top
+            bottomMargin: units.gu(1)
+        }
+
+        Flickable {
+            anchors.fill: parent
+
+            GridView {
+                id: devPeers
+                header: Item { height: units.gu(2) }
+                cellWidth: units.gu(13.5)
+                cellHeight: units.gu(16)
+                delegate: peerDelegate
+            }
+
+        }
+    }
+
+    Button {
+        id: cancelButton
+        text: "Cancel"
+        anchors {
+            left: parent.left
+            bottom: parent.bottom
+            margins: units.gu(1)
+        }
+        onClicked: {
+            if(root.activeTransfer) {
+                root.activeTransfer.state = ContentTransfer.Aborted;
+            }
+            cancelPressed();
+        }
+    }
+
+}

=== renamed file 'import/Ubuntu/Content/ContentImportHint.qml' => 'import/Ubuntu/Content/ContentTransferHint.qml'
--- import/Ubuntu/Content/ContentImportHint.qml	2013-10-21 16:36:02 +0000
+++ import/Ubuntu/Content/ContentTransferHint.qml	2014-03-20 13:33:31 +0000
@@ -20,11 +20,11 @@
 import Ubuntu.Content 0.1
 
 /*!
-    \qmltype ContentImportHint
+    \qmltype ContentTransferHint
     \inqmlmodule Ubuntu.Content 0.1
-    \brief Component that indicates that a trasnfer is active
+    \brief Component that indicates that a transfer is active
 
-    This component shows, that the transfer is currently running, and the source
+    This component shows that the transfer is currently running, and the source
     application is active. It blocks all input during that time.
     Place this component on top of your view.
 
@@ -33,7 +33,14 @@
 Item {
     id: root
 
-    /// The current running transfer
+    /*! 
+        \qmlproperty ContentTransfer ContentTransferHint::activeTransfer
+        \brief The ContentTransfer to monitor the status of.
+
+        This should be set to the currently active ContentTransfer, which
+        will then cause the ContentTransferHint to become visible while
+        the transfer is in progress.
+    */    
     property var activeTransfer
 
     opacity: internal.isTransferRunning ? 1.0 : 0.0

=== added file 'import/Ubuntu/Content/ResponsiveGridView.qml'
--- import/Ubuntu/Content/ResponsiveGridView.qml	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/ResponsiveGridView.qml	2014-03-20 13:33:31 +0000
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 0.1
+
+/*
+   Essentially a GridView where you can specify the maximum number of columns it can have.
+ */
+Item {
+    property int minimumHorizontalSpacing: units.gu(0.5)
+    // property int minimumNumberOfColumns: 2 // FIXME: not implemented
+    property int maximumNumberOfColumns: 6
+    readonly property int columns: gridView.columns
+    property alias verticalSpacing: gridView.verticalSpacing
+    readonly property alias margins: gridView.margin
+    property int delegateWidth
+    property int delegateHeight
+    property alias model: gridView.model
+    property alias delegate: gridView.delegate
+    readonly property int cellWidth: gridView.cellWidth
+    readonly property int cellHeight: gridView.cellHeight
+    readonly property int totalContentHeight: {
+        return contentHeightForRows(Math.ceil(gridView.model.count / columns))
+    }
+    property alias interactive: gridView.interactive
+    readonly property alias flicking: gridView.flicking
+    readonly property alias moving: gridView.moving
+    readonly property alias pressDelay: gridView.pressDelay
+    property alias delegateCreationBegin: gridView.delegateCreationBegin
+    property alias delegateCreationEnd: gridView.delegateCreationEnd
+    property alias highlightIndex: gridView.highlightIndex
+    readonly property alias currentItem: gridView.currentItem
+
+    function contentHeightForRows(rows) {
+        return rows * cellHeight + verticalSpacing
+    }
+
+    GridView {
+        id: gridView
+        objectName: "responsiveGridViewGrid"
+        anchors {
+            fill: parent
+            leftMargin: margin/2
+            rightMargin: margin/2
+            topMargin: verticalSpacing
+        }
+        clip: parent.height != totalContentHeight
+
+        function pixelToGU(value) {
+            return Math.floor(value / units.gu(1));
+        }
+
+        function spacingForColumns(columns) {
+            // spacing between columns as an integer number of GU, the remainder goes in the margins
+            var spacingGU = pixelToGU(allocatableHorizontalSpace / columns);
+            return units.gu(spacingGU);
+        }
+
+        function columnsForSpacing(spacing) {
+            // minimum margin is half of the spacing
+            return Math.max(1, Math.floor(parent.width / (delegateWidth + spacing)));
+        }
+
+        property real allocatableHorizontalSpace: parent.width - columns * delegateWidth
+        property int columns: Math.min(columnsForSpacing(minimumHorizontalSpacing), maximumNumberOfColumns)
+        property real horizontalSpacing: spacingForColumns(columns)
+        property real verticalSpacing: horizontalSpacing
+        property int margin: allocatableHorizontalSpace - columns * horizontalSpacing
+        property int highlightIndex: -1
+
+        cellWidth: delegateWidth + horizontalSpacing
+        cellHeight: delegateHeight + verticalSpacing
+
+        onHighlightIndexChanged: {
+            if (highlightIndex != -1) {
+                currentIndex = highlightIndex
+            }
+        }
+    }
+}

=== added file 'import/Ubuntu/Content/contenthandler.cpp'
--- import/Ubuntu/Content/contenthandler.cpp	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/contenthandler.cpp	2014-03-20 13:33:31 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "contenthandler.h"
+
+#include <QDebug>
+
+/*!
+   \qmltype ContentHandler
+   \instantiates ContentHandler
+   \inqmlmodule Ubuntu.Content 0.1
+
+   \sa ContentHub
+
+   \e {ContentHandler} is an enumeration of handler types:
+   \table
+   \header
+     \li Handler
+   \row
+     \li ContentHandler.Source
+   \row
+     \li ContentHandler.Destination
+   \row
+     \li ContentHandler.Share
+   \endtable
+ */
+
+ContentHandler::ContentHandler(QObject *parent)
+    : QObject(parent)
+{
+    qDebug() << Q_FUNC_INFO;
+}

=== added file 'import/Ubuntu/Content/contenthandler.h'
--- import/Ubuntu/Content/contenthandler.h	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/contenthandler.h	2014-03-20 13:33:31 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COM_UBUNTU_CONTENTHANDLER_H_
+#define COM_UBUNTU_CONTENTHANDLER_H_
+
+#include <QObject>
+
+class ContentHandler : public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(Handler)
+
+public:
+    enum Handler {
+        Source = 0,
+        Destination = 1,
+        Share = 2
+    };
+
+    ContentHandler(QObject *parent = nullptr);
+};
+
+#endif // COM_UBUNTU_CONTENTHANDLER_H_

=== modified file 'import/Ubuntu/Content/contenthub.cpp'
--- import/Ubuntu/Content/contenthub.cpp	2013-11-18 22:16:50 +0000
+++ import/Ubuntu/Content/contenthub.cpp	2014-03-20 13:33:31 +0000
@@ -25,6 +25,7 @@
 #include <com/ubuntu/content/peer.h>
 #include <com/ubuntu/content/type.h>
 
+#include <QStringList>
 #include <QDebug>
 
 /*!
@@ -42,36 +43,45 @@
  *     id: root
  *     width: units.gu(60)
  *     height: units.gu(90)
- *     Button {
- *         anchors {
- *             left: parent.left
- *             margins: units.gu(2)
- *          }
- *         text: "Import from default"
- *          onClicked: {
- *              var peer = ContentHub.defaultSourceForType(ContentType.Pictures);
- *              activeTransfer = ContentHub.importContent(ContentType.Pictures, peer);
- *         }
- *     }
- *     Button {
- *         anchors {
- *             right: parent.right
- *             margins: units.gu(2)
- *          }
- *         text: "Import from a selectable list"
- *          onClicked: {
- *              activeTransfer = ContentHub.importContent(ContentType.Pictures);
- *              activeTransfer.selectionType =ContentTransfer.Multiple;
- *              activeTransfer.start();
- *         }
- *     }
- *     ContentImportHint {
+ *     property list<ContentItem> importItems
+ *     property var activeTransfer
+ * 
+ *     ContentPeer {
+ *         id: picSourceSingle
+ *         contentType: ContentType.Pictures
+ *         handler: ContentHandler.Source
+ *         selectionType: ContentTransfer.Single
+ *     }
+ *
+ *     ContentPeer {
+ *         id: picSourceMulti
+ *         contentType: ContentType.Pictures
+ *         handler: ContentHandler.Source
+ *         selectionType: ContentTransfer.Multiple
+ *     }
+ *
+ *     Row {
+ *         Button {
+ *             text: "Import single item"
+ *             onClicked: {
+ *                 activeTransfer = picSourceSingle.request()
+ *             }
+ *         }
+ *
+ *         Button {
+ *             text: "Import multiple items"
+ *             onClicked: {
+ *                 activeTransfer = picSourceMulti.request()
+ *             }
+ *         }
+ *     }
+ *
+ *     ContentTransferHint {
  *         id: importHint
  *         anchors.fill: parent
  *         activeTransfer: root.activeTransfer
  *     }
- *     property list<ContentItem> importItems
- *     property var activeTransfer
+ *
  *     Connections {
  *         target: root.activeTransfer
  *         onStateChanged: {
@@ -107,6 +117,7 @@
     : QObject(parent),
       m_hub(0)
 {
+    qDebug() << Q_FUNC_INFO;
     m_hub = cuc::Hub::Client::instance();
     m_handler = new QmlImportExportHandler(this);
     m_hub->register_import_export_handler(m_handler);
@@ -115,121 +126,15 @@
             this, SLOT(handleImport(com::ubuntu::content::Transfer*)));
     connect(m_handler, SIGNAL(exportRequested(com::ubuntu::content::Transfer*)),
             this, SLOT(handleExport(com::ubuntu::content::Transfer*)));
-}
-
-/*!
- * \qmlmethod ContentHub::defaultSourceForType(ContentType)
- *
- *  Returns the default \a ContentPeer for the given \a ContentType
- */
-ContentPeer *ContentHub::defaultSourceForType(int type)
-{
-    qDebug() << Q_FUNC_INFO;
-
-    const cuc::Type &hubType = ContentType::contentType2HubType(type);
-    cuc::Peer hubPeer = m_hub->default_peer_for_type(hubType);
-
-    ContentPeer *qmlPeer = new ContentPeer(this);
-    qmlPeer->setPeer(hubPeer);
-
-    return qmlPeer;
-}
-
-/*!
- * \qmlmethod ContentHub::defaultStoreForType(ContentType)
- *
- *  Returns the default \a ContentStore for the given \a ContentType
- */
-ContentStore *ContentHub::defaultStoreForType(int type)
-{
-    qDebug() << Q_FUNC_INFO;
-
-    const cuc::Type &hubType = ContentType::contentType2HubType(type);
-    const cuc::Store *hubStore = m_hub->store_for_scope_and_type(cuc::app, hubType);
-
-    qDebug() << Q_FUNC_INFO << "STORE:" << hubStore->uri();
-
-    ContentStore *qmlStore = new ContentStore(this);
-    qmlStore->setStore(hubStore);
-
-    return qmlStore;
-}
-
-/*!
- * \qmlmethod ContentHub::knownSourcesForType(ContentType)
- *
- *  Returns all possible peers for the given ContentType
- *
- * \qml
- * import QtQuick 2.0
- * import Ubuntu.Components 0.1
- * import Ubuntu.Components.ListItems 0.1 as ListItem
- * import Ubuntu.Content 0.1
- *
- * MainView {
- *     property list<ContentPeer> peers
- *
- *     Component.onCompleted: {
- *         peers = ContentHub.knownSourcesForType(ContentType.Pictures);
- *     }
- *     ListView {
- *         anchors.fill: parent
- *         height: childrenRect.height
- *         model: peers
- *         delegate: ListItem.Standard {
- *             text: modelData.name
- *         }
- *     }
- * }
- * \endqml
- */
-QVariantList ContentHub::knownSourcesForType(int type)
-{
-    qDebug() << Q_FUNC_INFO;
-
-    const cuc::Type &hubType = ContentType::contentType2HubType(type);
-    QVector<cuc::Peer> hubPeers = m_hub->known_peers_for_type(hubType);
-
-    QVariantList qmlPeers;
-    foreach (const cuc::Peer &hubPeer, hubPeers) {
-        ContentPeer *qmlPeer = new ContentPeer(this);
-        qmlPeer->setPeer(hubPeer);
-        qmlPeers.append(QVariant::fromValue(qmlPeer));
-    }
-    return qmlPeers;
-}
-
-/*!
- * \qmlmethod ContentHub::importContent(ContentType)
- * \overload ContentHub::importContent(ContentType, ContentPeer)
- *
- * \brief Request to import data of \a ContentType from the default
- * ContentPeer
- */
-ContentTransfer *ContentHub::importContent(int type)
-{
-    qDebug() << Q_FUNC_INFO << static_cast<ContentType::Type>(type);
-
-    const cuc::Type &hubType = ContentType::contentType2HubType(type);
-//    FIXME show user a selection of possible peers instead
-    cuc::Peer hubPeer = m_hub->default_peer_for_type(hubType);
-
-    return importContent(hubType, hubPeer);
-}
-
-/*!
- * \qmlmethod ContentHub::importContent(ContentType, ContentPeer)
- * \overload ContentHub::importContent(ContentType)
- *
- * \brief Request to import data of \a ContentType from the
- * specified \a ContentPeer
- */
-ContentTransfer *ContentHub::importContent(int type, ContentPeer *peer)
-{
-    qDebug() << Q_FUNC_INFO << static_cast<ContentType::Type>(type) << peer;
-
-    const cuc::Type &hubType = ContentType::contentType2HubType(type);
-    return importContent(hubType, peer->peer());
+    connect(m_handler, SIGNAL(shareRequested(com::ubuntu::content::Transfer*)),
+            this, SLOT(handleShare(com::ubuntu::content::Transfer*)));
+}
+
+ContentHub *ContentHub::instance()
+{
+    qDebug() << Q_FUNC_INFO;
+    static ContentHub *contentHub = new ContentHub(nullptr);
+    return contentHub;
 }
 
 /*!
@@ -238,16 +143,47 @@
  * \a peer
  * \internal
  */
-ContentTransfer* ContentHub::importContent(const com::ubuntu::content::Type &hubType,
-                                           const com::ubuntu::content::Peer &hubPeer)
-{
-    cuc::Transfer *hubTransfer = m_hub->create_import_for_type_from_peer(hubType, hubPeer);
-// FIXME update tests so this can be enabled
-//    if (!hubTransfer)
-//        return nullptr;
-
-    ContentTransfer *qmlTransfer = new ContentTransfer(this);
-    qmlTransfer->setTransfer(hubTransfer, ContentTransfer::Import);
+ContentTransfer* ContentHub::importContent(cuc::Peer peer)
+{
+    qDebug() << Q_FUNC_INFO;
+
+    cuc::Transfer *hubTransfer = m_hub->create_import_from_peer(peer);
+    ContentTransfer *qmlTransfer = new ContentTransfer(this);
+    qmlTransfer->setTransfer(hubTransfer);
+    m_activeImports.insert(hubTransfer, qmlTransfer);
+    return qmlTransfer;
+}
+
+/*!
+ * \brief ContentHub::exportContent creates a ContentTransfer object
+ * \a type
+ * \a peer
+ * \internal
+ */
+ContentTransfer* ContentHub::exportContent(cuc::Peer peer)
+{
+    qDebug() << Q_FUNC_INFO;
+
+    cuc::Transfer *hubTransfer = m_hub->create_export_to_peer(peer);
+    ContentTransfer *qmlTransfer = new ContentTransfer(this);
+    qmlTransfer->setTransfer(hubTransfer);
+    m_activeImports.insert(hubTransfer, qmlTransfer);
+    return qmlTransfer;
+}
+
+/*!
+ * \brief ContentHub::shareContent creates a ContentTransfer object
+ * \a type
+ * \a peer
+ * \internal
+ */
+ContentTransfer* ContentHub::shareContent(cuc::Peer peer)
+{
+    qDebug() << Q_FUNC_INFO;
+
+    cuc::Transfer *hubTransfer = m_hub->create_share_to_peer(peer);
+    ContentTransfer *qmlTransfer = new ContentTransfer(this);
+    qmlTransfer->setTransfer(hubTransfer);
     m_activeImports.insert(hubTransfer, qmlTransfer);
     return qmlTransfer;
 }
@@ -283,8 +219,14 @@
         qmlTransfer = m_activeImports.take(transfer);
         qmlTransfer->collectItems();
     } else {
+        // If we don't have a reference to the transfer, it was created
+        // by another handler so this would be an Import
         qmlTransfer = new ContentTransfer(this);
-        qmlTransfer->setTransfer(transfer, ContentTransfer::Import);
+        qmlTransfer->setTransfer(transfer);
+        connect(qmlTransfer, SIGNAL(stateChanged()),
+                this, SLOT(updateState()));
+        qmlTransfer->collectItems();
+        Q_EMIT importRequested(qmlTransfer);
     }
 
     m_finishedImports.append(qmlTransfer);
@@ -298,11 +240,61 @@
 void ContentHub::handleExport(com::ubuntu::content::Transfer *transfer)
 {
     qDebug() << Q_FUNC_INFO;
-    ContentTransfer *qmlTransfer = new ContentTransfer(this);
-    qmlTransfer->setTransfer(transfer, ContentTransfer::Export);
-
-    Q_EMIT exportRequested(qmlTransfer);
-}
+    ContentTransfer *qmlTransfer = nullptr;
+    if (m_activeImports.contains(transfer))
+        qmlTransfer = m_activeImports.take(transfer);
+    else {
+        // If we don't have a reference to the transfer, it was created
+        // by another handler so this would be an Import
+        qmlTransfer = new ContentTransfer(this);
+        qmlTransfer->setTransfer(transfer);
+        m_activeImports.insert(transfer, qmlTransfer);
+        connect(qmlTransfer, SIGNAL(stateChanged()),
+                this, SLOT(updateState()));
+        Q_EMIT exportRequested(qmlTransfer);
+    }
+
+    m_finishedImports.append(qmlTransfer);
+    Q_EMIT finishedImportsChanged();
+}
+
+/*!
+ * \brief ContentHub::handleExport handles an incoming request for sharing content
+ * \internal
+ */
+void ContentHub::handleShare(com::ubuntu::content::Transfer *transfer)
+{
+    qDebug() << Q_FUNC_INFO;
+    ContentTransfer *qmlTransfer = nullptr;
+    if (m_activeImports.contains(transfer))
+    {
+        qmlTransfer = m_activeImports.take(transfer);
+        qmlTransfer->collectItems();
+    } else {
+        // If we don't have a reference to the transfer, it was created
+        // by another handler so this would be an Import
+        qmlTransfer = new ContentTransfer(this);
+        qmlTransfer->setTransfer(transfer);
+        connect(qmlTransfer, SIGNAL(stateChanged()),
+                this, SLOT(updateState()));
+        qmlTransfer->collectItems();
+        Q_EMIT shareRequested(qmlTransfer);
+    }
+
+    m_finishedImports.append(qmlTransfer);
+    Q_EMIT finishedImportsChanged();
+}
+
+void ContentHub::updateState()
+{
+    qDebug() << Q_FUNC_INFO;
+}
+
+/*!
+ * \qmlsignal ContentHub::importRequested(ContentTransfer transfer)
+ *
+ * The signal is triggered when an import is requested.
+ */
 
 /*!
  * \qmlsignal ContentHub::exportRequested(ContentTransfer transfer)
@@ -310,3 +302,9 @@
  * The signal is triggered when an export is requested.
  */
 
+/*!
+ * \qmlsignal ContentHub::shareRequested(ContentTransfer transfer)
+ *
+ * The signal is triggered when a share is requested.
+ */
+

=== modified file 'import/Ubuntu/Content/contenthub.h'
--- import/Ubuntu/Content/contenthub.h	2013-11-07 20:12:56 +0000
+++ import/Ubuntu/Content/contenthub.h	2014-03-20 13:33:31 +0000
@@ -21,10 +21,10 @@
 #include <QList>
 #include <QObject>
 #include <QQmlListProperty>
+#include "contentpeer.h"
+#include "contenttransfer.h"
 
-class ContentPeer;
 class ContentStore;
-class ContentTransfer;
 class QmlImportExportHandler;
 
 namespace com {
@@ -45,37 +45,40 @@
     Q_PROPERTY(QQmlListProperty<ContentTransfer> finishedImports READ finishedImports NOTIFY finishedImportsChanged)
 
 public:
-    ContentHub(QObject *parent = nullptr);
-
-    Q_INVOKABLE ContentPeer *defaultSourceForType(int type);
-    Q_INVOKABLE QVariantList knownSourcesForType(int type);
-
-    Q_INVOKABLE ContentStore *defaultStoreForType(int type);
-
-    Q_INVOKABLE ContentTransfer* importContent(int type);
-    Q_INVOKABLE ContentTransfer* importContent(int type, ContentPeer *peer);
+    ContentHub(const ContentHub&) = delete;
+
+    static ContentHub *instance();
 
     Q_INVOKABLE void restoreImports();
 
     QQmlListProperty<ContentTransfer> finishedImports();
 
+    Q_INVOKABLE ContentTransfer* importContent(com::ubuntu::content::Peer peer);
+    Q_INVOKABLE ContentTransfer* exportContent(com::ubuntu::content::Peer peer);
+    Q_INVOKABLE ContentTransfer* shareContent(com::ubuntu::content::Peer peer);
+
 Q_SIGNALS:
+    void importRequested(ContentTransfer *transfer);
     void exportRequested(ContentTransfer *transfer);
+    void shareRequested(ContentTransfer *transfer);
+
     void finishedImportsChanged();
 
 private Q_SLOTS:
-    void handleImport(com::ubuntu::content::Transfer * transfer);
-    void handleExport(com::ubuntu::content::Transfer * transfer);
+    void handleImport(com::ubuntu::content::Transfer* transfer);
+    void handleExport(com::ubuntu::content::Transfer* transfer);
+    void handleShare(com::ubuntu::content::Transfer* transfer);
+    void updateState();
 
 private:
-    ContentTransfer* importContent(const com::ubuntu::content::Type &hubType,
-                                   const com::ubuntu::content::Peer &hubPeer);
-
     QList<ContentTransfer *> m_finishedImports;
     QHash<com::ubuntu::content::Transfer *, ContentTransfer *> m_activeImports;
-
     com::ubuntu::content::Hub *m_hub;
     QmlImportExportHandler *m_handler;
+
+protected:
+    ContentHub(QObject* = nullptr);
+
 };
 
 #endif // COM_UBUNTU_CONTENTHUB_H_

=== modified file 'import/Ubuntu/Content/contenthubplugin.cpp'
--- import/Ubuntu/Content/contenthubplugin.cpp	2013-11-08 21:04:52 +0000
+++ import/Ubuntu/Content/contenthubplugin.cpp	2014-03-20 13:33:31 +0000
@@ -16,9 +16,13 @@
 
 #include "contenthubplugin.h"
 
+#include "contenthandler.h"
 #include "contenthub.h"
+#include "contenticonprovider.h"
 #include "contentitem.h"
 #include "contentpeer.h"
+#include "contentpeermodel.h"
+#include "contentscope.h"
 #include "contentstore.h"
 #include "contenttransfer.h"
 #include "contenttype.h"
@@ -27,6 +31,7 @@
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QDebug>
+#include <QIcon>
 
 /*!
  * \brief qml_content_hub function to unstatinate the ContentHub as a singleton in QML
@@ -36,7 +41,20 @@
     Q_UNUSED(engine)
     Q_UNUSED(scriptEngine)
     qDebug() << Q_FUNC_INFO;
-    return new ContentHub();
+    return ContentHub::instance();
+}
+
+/*!
+ * \reimp
+ */
+void ContentHubPlugin::initializeEngine(QQmlEngine * engine, const char * uri)
+{
+    Q_UNUSED(uri)
+    qDebug() << Q_FUNC_INFO;
+    QIcon::setThemeName("ubuntu-mobile");
+    QIcon::setThemeSearchPaths(QStringList() << ("/usr/share/icons/"));
+    ContentIconProvider *iconProvider = ContentIconProvider::instance();
+    engine->addImageProvider("content-hub", iconProvider);
 }
 
 /*!
@@ -50,10 +68,13 @@
     const int versionMajor = 0;
     const int versionMinor = 1;
 
+    qmlRegisterUncreatableType<ContentHandler>(uri, versionMajor, versionMinor, "ContentHandler", "Not creatable as an object, use only to retrieve handler enums (e.g. ContentHandler.Source)");
     qmlRegisterSingletonType<ContentHub>(uri, versionMajor, versionMinor, "ContentHub", qml_content_hub);
     qmlRegisterType<ContentItem>(uri, versionMajor, versionMinor, "ContentItem");
     qmlRegisterType<ContentPeer>(uri, versionMajor, versionMinor, "ContentPeer");
-    qmlRegisterUncreatableType<ContentStore>(uri, versionMajor, versionMinor, "ContentStore", "created by hub");
+    qmlRegisterType<ContentPeerModel>(uri, versionMajor, versionMinor, "ContentPeerModel");
+    qmlRegisterType<ContentScope>(uri, versionMajor, versionMinor, "ContentScope");
+    qmlRegisterType<ContentStore>(uri, versionMajor, versionMinor, "ContentStore");
     qmlRegisterUncreatableType<ContentTransfer>(uri, versionMajor, versionMinor, "ContentTransfer", "created by hub");
     qmlRegisterUncreatableType<ContentType>(uri, versionMajor, versionMinor, "ContentType", "Use only the type");
 }

=== modified file 'import/Ubuntu/Content/contenthubplugin.h'
--- import/Ubuntu/Content/contenthubplugin.h	2013-08-27 07:49:26 +0000
+++ import/Ubuntu/Content/contenthubplugin.h	2014-03-20 13:33:31 +0000
@@ -18,6 +18,7 @@
 #define COM_UBUNTU_CONTENT_PLUGIN_H_
 
 #include <QQmlExtensionPlugin>
+#include <QQmlEngine>
 
 class ContentHub;
 
@@ -27,6 +28,7 @@
     Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
 
 public:
+    void initializeEngine(QQmlEngine * engine, const char * uri);
     void registerTypes(const char *uri);
 
 private:

=== added file 'import/Ubuntu/Content/contenticonprovider.cpp'
--- import/Ubuntu/Content/contenticonprovider.cpp	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/contenticonprovider.cpp	2014-03-20 13:33:31 +0000
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "contenticonprovider.h"
+
+#include <QDebug>
+
+ContentIconProvider::ContentIconProvider()
+    : QQuickImageProvider(QQuickImageProvider::Image)
+{
+    qDebug() << Q_FUNC_INFO;
+
+    appIdImageMap = new QMap<QString, QImage>();
+}
+
+ContentIconProvider *ContentIconProvider::instance()
+{
+    static ContentIconProvider *contentIconProvider = new ContentIconProvider();
+    return contentIconProvider;
+}
+
+/*!
+ * \brief void ContentIconProvider::addImage
+ *
+ * Add an app's icon to the provider
+ */
+void ContentIconProvider::addImage(QString appId, QImage image)
+{
+    qDebug() << Q_FUNC_INFO;
+    appIdImageMap->insert(appId, image);
+}
+
+/*!
+ * \brief QImage ContentIconProvider::requestImage
+ *
+ * Returns the QImage for a given appId at the requested size
+ */
+QImage ContentIconProvider::requestImage(const QString &id, QSize *size, const QSize &requestedSize)
+{
+    Q_UNUSED(requestedSize)
+    qDebug() << Q_FUNC_INFO;
+
+    QImage image = appIdImageMap->value(id);
+    if(size) {
+        *size = image.size();
+    }
+
+    return image;
+}
+

=== added file 'import/Ubuntu/Content/contenticonprovider.h'
--- import/Ubuntu/Content/contenticonprovider.h	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/contenticonprovider.h	2014-03-20 13:33:31 +0000
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COM_UBUNTU_CONTENTICONPROVIDER_H_
+#define COM_UBUNTU_CONTENTICONPROVIDER_H_
+
+#include <QMap>
+#include <QQuickImageProvider>
+#include <QString>
+#include <QImage>
+
+class ContentIconProvider : public QQuickImageProvider
+{
+
+public:
+    ContentIconProvider();
+
+    static ContentIconProvider *instance();
+
+    QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize);
+    void addImage(QString appId, QImage image);
+
+private:
+    QMap<QString, QImage> *appIdImageMap;
+};
+
+#endif // COM_UBUNTU_CONTENTICONPROVIDER_H_

=== modified file 'import/Ubuntu/Content/contentpeer.cpp'
--- import/Ubuntu/Content/contentpeer.cpp	2013-11-07 20:12:56 +0000
+++ import/Ubuntu/Content/contentpeer.cpp	2014-03-20 13:33:31 +0000
@@ -14,11 +14,15 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "contenthandler.h"
+#include "contenthub.h"
+#include "contenticonprovider.h"
 #include "contentpeer.h"
+#include "contenttype.h"
 
 #include <com/ubuntu/content/peer.h>
-
 #include <QDebug>
+#include <QIcon>
 
 /*!
  * \qmltype ContentPeer
@@ -36,15 +40,21 @@
 
 ContentPeer::ContentPeer(QObject *parent)
     : QObject(parent),
-      m_peer(0)
+      m_peer(0),
+      m_handler(ContentHandler::Source),
+      m_contentType(ContentType::Unknown),
+      m_selectionType(ContentTransfer::Single),
+      m_explicit_peer(false)
 {
     qDebug() << Q_FUNC_INFO;
+
+    m_hub = cuc::Hub::Client::instance();
 }
 
 /*!
  * \qmlproperty string ContentPeer::name
  *
- * Returns user friendly name of the peer
+ * Returns user friendly name of the peer.
  */
 QString ContentPeer::name()
 {
@@ -54,8 +64,7 @@
 
 /*!
  * \qmlproperty string ContentPeer::appId
- *
- * Returns the Application id
+ * When set, this property allows for a specific application to be used as a peer.
  */
 const QString &ContentPeer::appId() const
 {
@@ -64,6 +73,23 @@
 }
 
 /*!
+ * \brief ContentPeer::setAppId
+ * \internal
+ * Sets the Application id
+ */
+void ContentPeer::setAppId(const QString& appId)
+{
+    qDebug() << Q_FUNC_INFO << appId;
+    this->setPeer(cuc::Peer{appId});
+}
+
+QImage &ContentPeer::icon()
+{
+    qDebug() << Q_FUNC_INFO;
+    return m_icon;
+}
+
+/*!
  * \brief ContentPeer::peer
  * \internal
  */
@@ -76,9 +102,145 @@
  * \brief ContentPeer::setPeer
  * \internal
  */
-void ContentPeer::setPeer(const cuc::Peer &peer)
+void ContentPeer::setPeer(const cuc::Peer &peer, bool explicitPeer)
 {
+    qDebug() << Q_FUNC_INFO;
     m_peer = peer;
+    m_explicit_peer = explicitPeer;
+    if (peer.iconData().isEmpty())
+    {
+        if (QIcon::hasThemeIcon(peer.iconName().toUtf8()))
+            m_icon = QIcon::fromTheme(peer.iconName().toUtf8()).pixmap(256).toImage();
+    } else
+        m_icon.loadFromData(peer.iconData());
+    ContentIconProvider *iconProvider = ContentIconProvider::instance();
+    iconProvider->addImage(appId(), m_icon);
+
     Q_EMIT nameChanged();
     Q_EMIT appIdChanged();
 }
+
+/*!
+ * \qmlproperty ContentHandler ContentPeer::handler
+ * Specifies which ContentHandler this peer should support (e.g. Source, Destination, Share).
+ */
+ContentHandler::Handler ContentPeer::handler()
+{
+    qDebug() << Q_FUNC_INFO;
+    return m_handler;
+}
+
+/*!
+ * \brief ContentPeer::setHandler
+ * \internal
+ */
+void ContentPeer::setHandler(ContentHandler::Handler handler)
+{   
+    qDebug() << Q_FUNC_INFO;
+    m_handler = handler;
+
+    Q_EMIT handlerChanged();
+}
+
+/*!
+ * \qmlproperty ContentType ContentPeer::contentType
+ * Specifies the ContentType this peer should support.
+ */
+ContentType::Type ContentPeer::contentType() 
+{
+    qDebug() << Q_FUNC_INFO;
+    return m_contentType;
+}
+
+/*!
+ * \brief ContentPeer::setContentType
+ * \internal
+ */
+void ContentPeer::setContentType(ContentType::Type contentType)
+{   
+    qDebug() << Q_FUNC_INFO;
+    m_contentType = contentType;
+
+    if(!m_explicit_peer) {
+        const cuc::Type &hubType = ContentType::contentType2HubType(m_contentType);
+        setPeer(m_hub->default_source_for_type(hubType), false);
+    }
+
+    Q_EMIT contentTypeChanged();
+}
+
+/*!
+ * \qmlproperty ContentTransfer.SelectionType ContentPeer::selectionType
+ * Specifies whether this peer is allowed to return multiple items.
+ */
+ContentTransfer::SelectionType ContentPeer::selectionType()
+{
+    qDebug() << Q_FUNC_INFO;
+    return m_selectionType;
+}
+
+/*!
+ * \brief ContentPeer::setSelectionType
+ * \internal
+ */
+void ContentPeer::setSelectionType(ContentTransfer::SelectionType selectionType)
+{
+    qDebug() << Q_FUNC_INFO;
+    m_selectionType = selectionType;
+
+    Q_EMIT selectionTypeChanged();
+}
+
+/*!
+ * \brief ContentPeer::isDefaultPeer
+ * \internal
+ */
+bool ContentPeer::isDefaultPeer()
+{
+    qDebug() << Q_FUNC_INFO;
+    return m_peer.isDefaultPeer();
+}
+
+/*!
+ * \qmlmethod ContentPeer::request()
+ *
+ * \brief Request an active transfer from this ContentPeer.
+ */
+ContentTransfer *ContentPeer::request()
+{   
+    qDebug() << Q_FUNC_INFO;
+    return request(nullptr);
+}
+
+/*!
+ * \qmlmethod ContentPeer::request(ContentStore)
+ *
+ * \brief Request to an active transfer from this ContentPeer and use
+ * a ContentStore for permanent storage.
+ */
+ContentTransfer *ContentPeer::request(ContentStore *store)
+{
+    qDebug() << Q_FUNC_INFO;
+
+    ContentHub *contentHub = ContentHub::instance();
+    ContentTransfer *qmlTransfer = NULL;
+    if(m_handler == ContentHandler::Source) {
+        qmlTransfer = contentHub->importContent(m_peer);
+    } else if (m_handler == ContentHandler::Destination) {
+        qmlTransfer = contentHub->exportContent(m_peer);
+    } else if (m_handler == ContentHandler::Share) {
+        qmlTransfer = contentHub->shareContent(m_peer);
+    }
+
+    qmlTransfer->setSelectionType(m_selectionType);
+    if(store) {
+        store->updateStore(m_contentType);
+        qmlTransfer->setStore(store);
+    }
+    
+    /* We only need to start it for import requests */
+    if (m_handler == ContentHandler::Source)
+        qmlTransfer->start();
+
+    return qmlTransfer;
+}

=== modified file 'import/Ubuntu/Content/contentpeer.h'
--- import/Ubuntu/Content/contentpeer.h	2013-10-23 12:06:13 +0000
+++ import/Ubuntu/Content/contentpeer.h	2014-03-20 13:33:31 +0000
@@ -17,32 +17,70 @@
 #ifndef COM_UBUNTU_CONTENTPEER_H_
 #define COM_UBUNTU_CONTENTPEER_H_
 
+#include "contenthandler.h"
+#include "contenttransfer.h"
+#include "contenttype.h"
+#include <com/ubuntu/content/hub.h>
 #include <com/ubuntu/content/peer.h>
 
 #include <QObject>
 #include <QString>
+#include <QImage>
 
 class ContentPeer : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QString name READ name NOTIFY nameChanged)
-    Q_PROPERTY(QString appId READ appId NOTIFY appIdChanged)
+    Q_PROPERTY(QString appId READ appId WRITE setAppId NOTIFY appIdChanged)
+    Q_PROPERTY(ContentHandler::Handler handler READ handler WRITE setHandler NOTIFY handlerChanged)
+    Q_PROPERTY(ContentType::Type contentType READ contentType WRITE setContentType NOTIFY contentTypeChanged)
+    Q_PROPERTY(ContentTransfer::SelectionType selectionType READ selectionType WRITE setSelectionType NOTIFY selectionTypeChanged)
+    Q_PROPERTY(QImage icon READ icon)
+    Q_PROPERTY(bool isDefaultPeer READ isDefaultPeer)
 
 public:
     ContentPeer(QObject *parent = nullptr);
+    ContentPeer(ContentType::Type type, QObject *parent);
+
+    Q_INVOKABLE ContentTransfer* request();
+    Q_INVOKABLE ContentTransfer* request(ContentStore *store);
 
     QString name();
     const QString &appId() const;
+    void setAppId(const QString&);
+    QImage &icon();
 
     const com::ubuntu::content::Peer &peer() const;
-    void setPeer(const com::ubuntu::content::Peer &peer);
+    void setPeer(const com::ubuntu::content::Peer &peer, bool explicitPeer = true);
+
+    ContentHandler::Handler handler();
+    void setHandler(ContentHandler::Handler handler);
+
+    ContentType::Type contentType();
+    void setContentType(ContentType::Type contentType);
+
+    ContentTransfer::SelectionType selectionType();
+    void setSelectionType(ContentTransfer::SelectionType selectionType);
+
+    bool isDefaultPeer();
 
 Q_SIGNALS:
     void nameChanged();
     void appIdChanged();
+    void handlerChanged();
+    void contentTypeChanged();
+    void selectionTypeChanged();
 
 private:
+    void init();
+
+    com::ubuntu::content::Hub *m_hub;
     com::ubuntu::content::Peer m_peer;
+    ContentHandler::Handler m_handler;
+    ContentType::Type m_contentType;
+    ContentTransfer::SelectionType m_selectionType;
+    bool m_explicit_peer;
+    QImage m_icon;
 };
 
 #endif // COM_UBUNTU_CONTENTPEER_H_

=== added file 'import/Ubuntu/Content/contentpeermodel.cpp'
--- import/Ubuntu/Content/contentpeermodel.cpp	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/contentpeermodel.cpp	2014-03-20 13:33:31 +0000
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "contentpeermodel.h"
+#include <stdio.h>
+
+#include <QDebug>
+
+namespace cuc = com::ubuntu::content;
+
+/*!
+ * \qmltype ContentPeerModel
+ * \instantiates ContentPeerModel
+ * \inqmlmodule Ubuntu.Content 0.1
+ * \brief A list of applications that can export or import a ContentType
+ *
+ * A ContentPeerModel provides a list of all applications that are registered
+ * in the ContentHub as a source or destination of a ContentType
+ *
+ * See documentation for ContentPeer
+ */
+
+ContentPeerModel::ContentPeerModel(QObject *parent)
+    : QObject(parent),
+      m_contentType(ContentType::Unknown),
+      m_handler(ContentHandler::Source),
+      m_complete(false)
+{
+    qDebug() << Q_FUNC_INFO;
+    m_hub = cuc::Hub::Client::instance();
+}
+
+/*!
+ * \brief \reimp
+ * \internal
+ */
+void ContentPeerModel::classBegin()
+{
+
+}
+
+/*!
+ * \brief \reimp
+ * \internal
+ */
+void ContentPeerModel::componentComplete()
+{
+    m_complete = true;
+    QTimer::singleShot(0, this, SLOT(findPeers()));
+}
+
+/*!
+ * \qmlproperty ContentType ContentPeerModel::contentType
+ *
+ * Specifies which ContentType discovered peers should support.
+ */
+ContentType::Type ContentPeerModel::contentType()
+{
+    qDebug() << Q_FUNC_INFO;
+    return m_contentType;
+}
+
+/*!
+ * \brief ContentPeerModel::setContentType
+ * \internal
+ */
+void ContentPeerModel::setContentType(ContentType::Type contentType)
+{
+    qDebug() << Q_FUNC_INFO;
+    m_contentType = contentType;
+    if (m_complete) {
+        findPeers();
+    }
+    Q_EMIT contentTypeChanged();
+}
+
+/*!
+ * \brief ContentPeerModel::findPeers
+ * \internal
+ */
+void ContentPeerModel::findPeers() {
+    qDebug() << Q_FUNC_INFO;
+    m_peers.clear();
+    QCoreApplication::processEvents();
+    if(m_contentType == ContentType::All) {
+        appendPeersForContentType(ContentType::Unknown);
+        appendPeersForContentType(ContentType::Documents);
+        appendPeersForContentType(ContentType::Pictures);
+        appendPeersForContentType(ContentType::Music);
+        appendPeersForContentType(ContentType::Contacts);
+    } else {
+        appendPeersForContentType(m_contentType);
+    }
+    Q_EMIT findPeersCompleted();
+}
+
+/*!
+ * \brief ContentPeerModel::appendPeersForContentType
+ * \internal
+ */
+void ContentPeerModel::appendPeersForContentType(ContentType::Type contentType)
+{
+    qDebug() << Q_FUNC_INFO;
+    const cuc::Type &hubType = ContentType::contentType2HubType(contentType);
+    QVector<cuc::Peer> hubPeers;
+    if (m_handler == ContentHandler::Destination) {
+        hubPeers = m_hub->known_destinations_for_type(hubType);
+    } else if (m_handler == ContentHandler::Share) {
+        hubPeers = m_hub->known_shares_for_type(hubType);
+    } else {
+        hubPeers = m_hub->known_sources_for_type(hubType);
+    }
+
+    Q_FOREACH (const cuc::Peer &hubPeer, hubPeers) 
+    {
+        if(!hubPeer.id().isEmpty()) 
+        {
+            ContentPeer *qmlPeer = new ContentPeer();
+            qmlPeer->setPeer(hubPeer);
+            qmlPeer->setContentType(contentType);
+            qmlPeer->setHandler(m_handler);
+            if(qmlPeer->isDefaultPeer()) 
+            {
+                m_peers.prepend(qmlPeer);
+            } else {
+                m_peers.append(qmlPeer);
+            }
+            Q_EMIT peersChanged();
+        }
+        QCoreApplication::processEvents();
+    }
+}
+
+/*!
+ * \qmlproperty ContentHandler ContentPeerModel::handler
+ *
+ * Specifies which ContentHandler discovered peers should support.
+ */
+ContentHandler::Handler ContentPeerModel::handler() 
+{
+    qDebug() << Q_FUNC_INFO;
+    return m_handler;
+}
+
+/*!
+ * \brief ContentPeerModel::setHandler
+ * \internal
+ */
+void ContentPeerModel::setHandler(ContentHandler::Handler handler)
+{
+    qDebug() << Q_FUNC_INFO;
+    m_handler = handler;
+    if (m_complete) {
+        findPeers();
+    }
+    Q_EMIT handlerChanged();
+}
+
+/*!
+ * \qmlproperty list<ContentPeer> ContentPeerModel::peers
+ *
+ * Provides a list of discovered peers matching the requested ContentType and ContentHandler.
+ */
+QQmlListProperty<ContentPeer> ContentPeerModel::peers()
+{
+    qDebug() << Q_FUNC_INFO;
+    return QQmlListProperty<ContentPeer>(this, m_peers);
+}
+

=== added file 'import/Ubuntu/Content/contentpeermodel.h'
--- import/Ubuntu/Content/contentpeermodel.h	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/contentpeermodel.h	2014-03-20 13:33:31 +0000
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COM_UBUNTU_CONTENTPEERMODEL_H_
+#define COM_UBUNTU_CONTENTPEERMODEL_H_
+
+#include "contentpeer.h"
+#include "contenttype.h"
+#include "contenthandler.h"
+#include <com/ubuntu/content/hub.h>
+
+#include <QObject>
+#include <QVariant>
+#include <QQmlListProperty>
+#include <QQmlParserStatus>
+
+class ContentPeerModel : public QObject, public QQmlParserStatus
+{
+    Q_OBJECT
+    Q_INTERFACES(QQmlParserStatus)
+    Q_PROPERTY(ContentType::Type contentType READ contentType WRITE setContentType NOTIFY contentTypeChanged)
+    Q_PROPERTY(ContentHandler::Handler handler READ handler WRITE setHandler NOTIFY handlerChanged)
+    Q_PROPERTY(QQmlListProperty<ContentPeer> peers READ peers NOTIFY peersChanged)
+
+public:
+    ContentPeerModel(QObject *parent = nullptr);
+
+    void classBegin();
+    void componentComplete();
+    ContentType::Type contentType();
+    void setContentType(ContentType::Type contentType);
+    void appendPeersForContentType(ContentType::Type contentType);
+    ContentHandler::Handler handler();
+    void setHandler(ContentHandler::Handler handler);
+    QQmlListProperty<ContentPeer> peers();
+
+Q_SIGNALS:
+    void contentTypeChanged();
+    void handlerChanged();
+    void peersChanged();
+    void findPeersCompleted();
+
+public Q_SLOTS:
+    void findPeers();
+
+private:
+    com::ubuntu::content::Hub *m_hub;
+    ContentType::Type m_contentType;
+    ContentHandler::Handler m_handler;
+    QList<ContentPeer *> m_peers;
+    bool m_complete;
+};
+
+#endif // COM_UBUNTU_CONTENTPEERMODEL_H_

=== added file 'import/Ubuntu/Content/contentscope.cpp'
--- import/Ubuntu/Content/contentscope.cpp	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/contentscope.cpp	2014-03-20 13:33:31 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "contentscope.h"
+
+#include <QDebug>
+
+/*!
+   \qmltype ContentScope
+   \instantiates ContentScope
+   \inqmlmodule Ubuntu.Content 0.1
+
+   \sa ContentStore
+
+   \e {ContentScope} is an enumeration of scope types:
+   \table
+   \header
+     \li Scope
+   \row
+     \li ContentScope.System
+   \row
+     \li ContentScope.User
+   \row
+     \li ContentScope.App
+   \endtable
+ */
+
+ContentScope::ContentScope(QObject *parent)
+    : QObject(parent)
+{
+    qDebug() << Q_FUNC_INFO;
+}
+
+/*!
+ * \brief ContentScope::contentScope2HubScope converts a ContentScope::Scope to a
+ * com::ubuntu::content::Scope
+ * \internal
+ */
+com::ubuntu::content::Scope ContentScope::contentScope2HubScope(int scope)
+{
+    Scope cscope = static_cast<Scope>(scope);
+    qDebug() << Q_FUNC_INFO << cscope;
+    return contentScope2HubScope(cscope);
+}
+
+/*!
+ * \brief ContentScope::contentScope2HubScope converts a ContentScope::Scope to a
+ * com::ubuntu::content::Scope
+ * \internal
+ */
+com::ubuntu::content::Scope ContentScope::contentScope2HubScope(Scope scope)
+{
+    return static_cast<com::ubuntu::content::Scope>(scope);
+}
+

=== added file 'import/Ubuntu/Content/contentscope.h'
--- import/Ubuntu/Content/contentscope.h	1970-01-01 00:00:00 +0000
+++ import/Ubuntu/Content/contentscope.h	2014-03-20 13:33:31 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COM_UBUNTU_CONTENTSCOPE_H_
+#define COM_UBUNTU_CONTENTSCOPE_H_
+
+#include <com/ubuntu/content/scope.h>
+
+#include <QObject>
+
+class ContentScope : public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(Scope)
+
+public:
+    enum Scope {
+        System = 0,
+        User = 1,
+        App = 2
+    };
+
+    ContentScope(QObject *parent = nullptr);
+
+    static com::ubuntu::content::Scope contentScope2HubScope(int scope);
+    static com::ubuntu::content::Scope contentScope2HubScope(Scope scope);
+
+};
+
+#endif // COM_UBUNTU_CONTENTSCOPE_H_

=== modified file 'import/Ubuntu/Content/contentstore.cpp'
--- import/Ubuntu/Content/contentstore.cpp	2013-10-22 20:44:52 +0000
+++ import/Ubuntu/Content/contentstore.cpp	2014-03-20 13:33:31 +0000
@@ -14,7 +14,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "contentpeer.h"
 #include "contentstore.h"
+#include "contenttype.h"
 
 #include <QDebug>
 
@@ -23,16 +25,20 @@
  * \instantiates ContentStore
  * \inqmlmodule Ubuntu.Content 0.1
  *
- * See documentation for ContentHub
+ * A ContentStore allows for the permanent storage of a transfered item.
+ *
+ * See documentation for ContentHub and ContentScope
  */
 
 namespace cuc = com::ubuntu::content;
 
 ContentStore::ContentStore(QObject *parent)
     : QObject(parent),
-      m_store(0)
+      m_store(0),
+      m_scope(ContentScope::System)
 {
     qDebug() << Q_FUNC_INFO;
+    m_hub = cuc::Hub::Client::instance();
 }
 
 /*!
@@ -42,7 +48,14 @@
  */
 const QString &ContentStore::uri() const
 {
+    static const QString __empty;
+
     qDebug() << Q_FUNC_INFO;
+
+    if ( ! m_store) {
+        qWarning() << "Accessing ContentStore uri with NULL internal store";
+        return __empty;
+    }
     return m_store->uri();
 }
 
@@ -63,9 +76,43 @@
 void ContentStore::setStore(const com::ubuntu::content::Store *store)
 {
     qDebug() << Q_FUNC_INFO;
-    //if (store == m_store)
-    //    return;
-
     m_store = store;
     Q_EMIT uriChanged();
 }
+
+/*!
+ * \qmlproperty ContentScope ContentStore::scope
+ *
+ * Specifies the ContentScope for this store.
+ */
+ContentScope::Scope ContentStore::scope()
+{   
+    qDebug() << Q_FUNC_INFO;
+    return m_scope;
+}
+
+/*!
+ * \brief ContentStore::setScope
+ * \internal
+ */
+void ContentStore::setScope(ContentScope::Scope scope)
+{   
+    qDebug() << Q_FUNC_INFO;
+    m_scope = scope;
+
+    Q_EMIT scopeChanged();
+}
+
+/*!
+ * \brief ContentStore::updateStore
+ * \internal
+ */
+void ContentStore::updateStore(ContentType::Type contentType)
+{
+    qDebug() << Q_FUNC_INFO;
+
+    com::ubuntu::content::Scope hubScope = ContentScope::contentScope2HubScope(m_scope);
+    const com::ubuntu::content::Type &hubType = ContentType::contentType2HubType(contentType);
+    setStore(m_hub->store_for_scope_and_type(hubScope, hubType));
+}
+

=== modified file 'import/Ubuntu/Content/contentstore.h'
--- import/Ubuntu/Content/contentstore.h	2013-09-30 13:30:45 +0000
+++ import/Ubuntu/Content/contentstore.h	2014-03-20 13:33:31 +0000
@@ -17,6 +17,9 @@
 #ifndef COM_UBUNTU_CONTENTSTORE_H_
 #define COM_UBUNTU_CONTENTSTORE_H_
 
+#include "contentscope.h"
+#include "contenttype.h"
+#include <com/ubuntu/content/hub.h>
 #include <com/ubuntu/content/store.h>
 
 #include <QObject>
@@ -26,6 +29,7 @@
 {
     Q_OBJECT
     Q_PROPERTY(QString uri READ uri NOTIFY uriChanged)
+    Q_PROPERTY(ContentScope::Scope scope READ scope WRITE setScope NOTIFY scopeChanged)
 
 public:
     ContentStore(QObject *parent = nullptr);
@@ -35,11 +39,19 @@
     const com::ubuntu::content::Store *store() const;
     void setStore(const com::ubuntu::content::Store *store);
 
+    ContentScope::Scope scope();
+    void setScope(ContentScope::Scope scope);
+
+    void updateStore(ContentType::Type type);
+
 Q_SIGNALS:
     void uriChanged();
+    void scopeChanged();
 
 private:
+    com::ubuntu::content::Hub *m_hub;
     const com::ubuntu::content::Store *m_store;
+    ContentScope::Scope m_scope;
 };
 
 #endif // COM_UBUNTU_CONTENTSTORE_H_

=== modified file 'import/Ubuntu/Content/contenttransfer.cpp'
--- import/Ubuntu/Content/contenttransfer.cpp	2013-10-22 20:44:52 +0000
+++ import/Ubuntu/Content/contenttransfer.cpp	2014-03-20 13:33:31 +0000
@@ -82,18 +82,24 @@
 
 void ContentTransfer::setState(ContentTransfer::State state)
 {
-    qDebug() << Q_FUNC_INFO;
+    qDebug() << Q_FUNC_INFO << state;
     if (!m_transfer)
         return;
 
-    if (state == Charged && m_state == InProgress && m_direction == Export) {
+    if (state == Charged && m_state == InProgress) {
+        qDebug() << Q_FUNC_INFO << "Charged";
         QVector<cuc::Item> hubItems;
         hubItems.reserve(m_items.size());
-        foreach (const ContentItem *citem, m_items) {
+        Q_FOREACH (const ContentItem *citem, m_items) {
             hubItems.append(citem->item());
         }
         m_transfer->charge(hubItems);
-    }
+        return;
+    } else if (state == Aborted) {
+        qDebug() << Q_FUNC_INFO << "Aborted";
+        m_transfer->abort();
+    } else
+        updateState();
 }
 
 /*!
@@ -112,6 +118,9 @@
   \row
     \li ContentTransfer.Export
     \li Transfer is a request to export content.
+  \row
+    \li ContentTransfer.Share
+    \li Transfer is a request to share content.
   \endtable
  */
 ContentTransfer::Direction ContentTransfer::direction() const
@@ -161,7 +170,7 @@
 QQmlListProperty<ContentItem> ContentTransfer::items()
 {
     qDebug() << Q_FUNC_INFO;
-    if (m_state == Charged && m_direction == Import) {
+    if (m_state == Charged) {
         collectItems();
     }
     return QQmlListProperty<ContentItem>(this, m_items);
@@ -174,7 +183,7 @@
  */
 bool ContentTransfer::start()
 {
-    qDebug() << Q_FUNC_INFO;
+    qDebug() << Q_FUNC_INFO << m_transfer->id() << ":" << m_state;
     if (m_state == Created) {
         return m_transfer->start();
     } else {
@@ -213,7 +222,10 @@
         qWarning() << Q_FUNC_INFO << "invalid transfer";
         return;
     }
-    m_transfer->setStore(contentStore->store());
+
+    if(contentStore->store() != nullptr) {
+        m_transfer->setStore(contentStore->store());
+    }
 }
 
 /*!
@@ -230,7 +242,7 @@
  * \brief ContentTransfer::setTransfer
  * \internal
  */
-void ContentTransfer::setTransfer(com::ubuntu::content::Transfer *transfer, Direction direction)
+void ContentTransfer::setTransfer(com::ubuntu::content::Transfer *transfer)
 {
     if (m_transfer) {
         qWarning() << Q_FUNC_INFO << "the transfer object was already set";
@@ -242,21 +254,17 @@
         return;
     }
 
-    qDebug() << Q_FUNC_INFO;
-
-    m_direction = direction;
     m_transfer = transfer;
+    m_direction = static_cast<ContentTransfer::Direction>(transfer->direction());
+    qDebug() << Q_FUNC_INFO << "Direction:" << m_direction;
+
+    connect(m_transfer, SIGNAL(selectionTypeChanged()), this, SLOT(updateSelectionType()));
+    connect(m_transfer, SIGNAL(storeChanged()), this, SLOT(updateStore()));
+    connect(m_transfer, SIGNAL(stateChanged()), this, SLOT(updateState()));
 
     updateSelectionType();
     updateStore();
     updateState();
-
-    if (m_state == Charged && m_direction == Import)
-        collectItems();
-
-    connect(m_transfer, SIGNAL(selectionTypeChanged()), this, SLOT(updateSelectionType()));
-    connect(m_transfer, SIGNAL(storeChanged()), this, SLOT(updateStore()));
-    connect(m_transfer, SIGNAL(stateChanged()), this, SLOT(updateState()));
 }
 
 /*!
@@ -266,14 +274,14 @@
 void ContentTransfer::collectItems()
 {
     qDebug() << Q_FUNC_INFO;
-    if (m_state != Charged || m_direction != Import)
+    if (m_state != Charged)
         return;
 
     qDeleteAll(m_items);
     m_items.clear();
 
     QVector<cuc::Item> transfereditems = m_transfer->collect();
-    foreach (const cuc::Item &hubItem, transfereditems) {
+    Q_FOREACH (const cuc::Item &hubItem, transfereditems) {
         ContentItem *qmlItem = new ContentItem(this);
         qmlItem->setItem(hubItem);
         m_items.append(qmlItem);
@@ -287,9 +295,13 @@
  */
 void ContentTransfer::updateState()
 {
-    qDebug() << Q_FUNC_INFO;
+    qDebug() << Q_FUNC_INFO << m_transfer->state();
+
     if (!m_transfer)
+    {
+        qWarning() << Q_FUNC_INFO << "Invalid transfer";
         return;
+    }
 
     m_state = static_cast<ContentTransfer::State>(m_transfer->state());
     Q_EMIT stateChanged();
@@ -303,7 +315,10 @@
 {
     qDebug() << Q_FUNC_INFO;
     if (!m_transfer)
+    {
+        qWarning() << Q_FUNC_INFO << "Invalid transfer";
         return;
+    }
 
     m_selectionType = static_cast<ContentTransfer::SelectionType>(m_transfer->selectionType());
     Q_EMIT selectionTypeChanged();
@@ -318,7 +333,10 @@
 {
     qDebug() << Q_FUNC_INFO;
     if (!m_transfer)
+    {
+        qWarning() << Q_FUNC_INFO << "Invalid transfer";
         return;
+    }
 
     m_store = m_transfer->store();
     Q_EMIT storeChanged();

=== modified file 'import/Ubuntu/Content/contenttransfer.h'
--- import/Ubuntu/Content/contenttransfer.h	2013-10-21 17:16:57 +0000
+++ import/Ubuntu/Content/contenttransfer.h	2014-03-20 13:33:31 +0000
@@ -51,8 +51,9 @@
         Finalized = com::ubuntu::content::Transfer::finalized
     };
     enum Direction {
-        Import,
-        Export
+        Import = com::ubuntu::content::Transfer::Import,
+        Export = com::ubuntu::content::Transfer::Export,
+        Share = com::ubuntu::content::Transfer::Share
     };
     enum SelectionType {
         Single = com::ubuntu::content::Transfer::SelectionType::single,
@@ -78,7 +79,7 @@
     Q_INVOKABLE void setStore(ContentStore *contentStore);
 
     com::ubuntu::content::Transfer *transfer() const;
-    void setTransfer(com::ubuntu::content::Transfer *transfer, Direction direction);
+    void setTransfer(com::ubuntu::content::Transfer *transfer);
 
     void collectItems();
 

=== modified file 'import/Ubuntu/Content/contenttype.cpp'
--- import/Ubuntu/Content/contenttype.cpp	2013-12-10 15:59:15 +0000
+++ import/Ubuntu/Content/contenttype.cpp	2014-03-20 13:33:31 +0000
@@ -44,7 +44,10 @@
      \li Music
    \row
      \li ContentType.Contacts
-     \li Music
+     \li Contacts
+   \row
+     \li ContentType.All
+     \li Any of the above content types
    \endtable
  */
 

=== modified file 'import/Ubuntu/Content/contenttype.h'
--- import/Ubuntu/Content/contenttype.h	2013-12-10 15:59:15 +0000
+++ import/Ubuntu/Content/contenttype.h	2014-03-20 13:33:31 +0000
@@ -29,6 +29,7 @@
 
 public:
     enum Type {
+        All = -1,
         Unknown = 0,
         Documents = 1,
         Pictures = 2,

=== modified file 'import/Ubuntu/Content/qmldir'
--- import/Ubuntu/Content/qmldir	2013-09-27 13:11:45 +0000
+++ import/Ubuntu/Content/qmldir	2014-03-20 13:33:31 +0000
@@ -1,4 +1,5 @@
 module Ubuntu.Content
 plugin ubuntu-content-hub-plugin
 
-ContentImportHint 0.1 ContentImportHint.qml
+ContentTransferHint 0.1 ContentTransferHint.qml
+ContentPeerPicker 0.1 ContentPeerPicker.qml

=== modified file 'import/Ubuntu/Content/qmlimportexporthandler.cpp'
--- import/Ubuntu/Content/qmlimportexporthandler.cpp	2013-08-23 15:51:35 +0000
+++ import/Ubuntu/Content/qmlimportexporthandler.cpp	2014-03-20 13:33:31 +0000
@@ -50,3 +50,11 @@
     Q_EMIT exportRequested(transfer);
 }
 
+/*!
+ * \reimp
+ */
+void QmlImportExportHandler::handle_share(com::ubuntu::content::Transfer *transfer)
+{
+    qDebug() << Q_FUNC_INFO;
+    Q_EMIT shareRequested(transfer);
+}

=== modified file 'import/Ubuntu/Content/qmlimportexporthandler.h'
--- import/Ubuntu/Content/qmlimportexporthandler.h	2013-08-23 15:51:35 +0000
+++ import/Ubuntu/Content/qmlimportexporthandler.h	2014-03-20 13:33:31 +0000
@@ -36,10 +36,12 @@
 
     Q_INVOKABLE virtual void handle_import(com::ubuntu::content::Transfer *transfer);
     Q_INVOKABLE virtual void handle_export(com::ubuntu::content::Transfer *transfer);
+    Q_INVOKABLE virtual void handle_share(com::ubuntu::content::Transfer *transfer);
 
 Q_SIGNALS:
     void importRequested(com::ubuntu::content::Transfer*);
     void exportRequested(com::ubuntu::content::Transfer*);
+    void shareRequested(com::ubuntu::content::Transfer*);
 };
 
 #endif // COM_UBUNTU_QMLIMPORTEXPORTHANDLER_H_

=== modified file 'include/com/ubuntu/content/hub.h'
--- include/com/ubuntu/content/hub.h	2013-09-10 14:11:37 +0000
+++ include/com/ubuntu/content/hub.h	2014-03-20 13:33:31 +0000
@@ -51,9 +51,14 @@
 
     Q_INVOKABLE virtual void register_import_export_handler(ImportExportHandler* handler);
     Q_INVOKABLE virtual const Store* store_for_scope_and_type(Scope scope, Type type);
-    Q_INVOKABLE virtual Peer default_peer_for_type(Type type);
-    Q_INVOKABLE virtual QVector<Peer> known_peers_for_type(Type type);
-    Q_INVOKABLE virtual Transfer* create_import_for_type_from_peer(Type type, Peer peer);
+    Q_INVOKABLE virtual Peer default_source_for_type(Type type);
+    Q_INVOKABLE virtual QVector<Peer> known_sources_for_type(Type type);
+    Q_INVOKABLE virtual QVector<Peer> known_destinations_for_type(Type type);
+    Q_INVOKABLE virtual QVector<Peer> known_shares_for_type(Type type);
+    Q_INVOKABLE virtual Transfer* create_import_from_peer(Peer peer);
+    Q_INVOKABLE virtual Transfer* create_export_to_peer(Peer peer);
+    Q_INVOKABLE virtual Transfer* create_share_to_peer(Peer peer);
+
 
     Q_INVOKABLE virtual void quit();
        

=== modified file 'include/com/ubuntu/content/import_export_handler.h'
--- include/com/ubuntu/content/import_export_handler.h	2013-08-15 13:01:40 +0000
+++ include/com/ubuntu/content/import_export_handler.h	2014-03-20 13:33:31 +0000
@@ -38,6 +38,7 @@
 
     Q_INVOKABLE virtual void handle_import(Transfer*) = 0;
     Q_INVOKABLE virtual void handle_export(Transfer*) = 0;
+    Q_INVOKABLE virtual void handle_share(Transfer*) = 0;
 
   protected:
     ImportExportHandler(QObject* parent = nullptr); 

=== modified file 'include/com/ubuntu/content/peer.h'
--- include/com/ubuntu/content/peer.h	2013-10-01 16:55:39 +0000
+++ include/com/ubuntu/content/peer.h	2014-03-20 13:33:31 +0000
@@ -18,8 +18,10 @@
 #ifndef COM_UBUNTU_CONTENT_PEER_H_
 #define COM_UBUNTU_CONTENT_PEER_H_
 
+#include <QtDBus>
 #include <QObject>
 #include <QSharedPointer>
+#include <QImage>
 
 namespace com
 {
@@ -30,13 +32,14 @@
 class Peer : public QObject
 {
     Q_OBJECT
-    Q_PROPERTY(QString id READ id())
-    Q_PROPERTY(QString name READ name())
+    Q_PROPERTY(QString id READ id)
+    Q_PROPERTY(QString name READ name WRITE setName)
+    Q_PROPERTY(QString iconName READ iconName WRITE setIconName)
+    Q_PROPERTY(bool isDefaultPeer READ isDefaultPeer)
 
   public:
     static const Peer& unknown();
-
-    Peer(const QString& id = QString(), QObject* parent = nullptr);
+    Peer(const QString& id = QString(), bool isDefaultPeer = false, QObject* parent = nullptr);
     Peer(const Peer& rhs);
     virtual ~Peer();
     
@@ -44,7 +47,13 @@
     bool operator==(const Peer& rhs) const;
 
     Q_INVOKABLE virtual const QString& id() const;
-    Q_INVOKABLE virtual QString name();
+    Q_INVOKABLE virtual QString name() const;
+    Q_INVOKABLE void setName(const QString&);
+    Q_INVOKABLE virtual QByteArray iconData() const;
+    Q_INVOKABLE void setIconData(const QByteArray&);
+    Q_INVOKABLE virtual QString iconName() const;
+    Q_INVOKABLE void setIconName(const QString&);
+    Q_INVOKABLE virtual bool isDefaultPeer() const;
 
   private:
     struct Private;
@@ -54,4 +63,14 @@
 }
 }
 
+Q_DECL_EXPORT
+QDBusArgument &operator<<(QDBusArgument &argument,
+                const com::ubuntu::content::Peer &peer);
+
+Q_DECL_EXPORT
+const QDBusArgument &operator>>(const QDBusArgument &argument,
+                com::ubuntu::content::Peer &peer);
+
+Q_DECLARE_METATYPE(com::ubuntu::content::Peer)
+
 #endif // COM_UBUNTU_CONTENT_PEER_H_

=== modified file 'include/com/ubuntu/content/transfer.h'
--- include/com/ubuntu/content/transfer.h	2013-10-01 16:55:39 +0000
+++ include/com/ubuntu/content/transfer.h	2014-03-20 13:33:31 +0000
@@ -52,11 +52,13 @@
     Q_OBJECT
     Q_ENUMS(State)
     Q_ENUMS(SelectionType)
+    Q_ENUMS(Direction)
     Q_PROPERTY(int id READ id)
     Q_PROPERTY(State state READ state NOTIFY stateChanged)
     Q_PROPERTY(QVector<Item> items READ collect WRITE charge)
     Q_PROPERTY(Store store READ store NOTIFY storeChanged)
     Q_PROPERTY(SelectionType selectionType READ selectionType WRITE setSelectionType NOTIFY selectionTypeChanged)
+    Q_PROPERTY(Direction direction READ direction)
 
   public:
     enum State
@@ -76,6 +78,13 @@
         multiple
     };
 
+    enum Direction
+    {
+        Import,
+        Export,
+        Share
+    };
+
     Transfer(const Transfer&) = delete;
     virtual ~Transfer();
 
@@ -84,6 +93,7 @@
     Q_INVOKABLE virtual int id() const;
     Q_INVOKABLE virtual State state() const;
     Q_INVOKABLE virtual SelectionType selectionType() const;
+    Q_INVOKABLE virtual Direction direction() const;
     Q_INVOKABLE virtual bool start();
     Q_INVOKABLE virtual bool abort();
     Q_INVOKABLE virtual bool finalize();

=== modified file 'include/com/ubuntu/content/type.h'
--- include/com/ubuntu/content/type.h	2013-12-10 15:59:15 +0000
+++ include/com/ubuntu/content/type.h	2014-03-20 13:33:31 +0000
@@ -30,6 +30,7 @@
 namespace detail
 {
 class Service;
+class Hook;
 }
 class Type : public QObject
 {
@@ -59,6 +60,7 @@
   protected:
     friend struct Known;
     friend class detail::Service;
+    friend class detail::Hook;
 
     explicit Type(const QString&, QObject* = nullptr);
     

=== modified file 'libcontent-hub.pc.in'
--- libcontent-hub.pc.in	2013-09-30 21:28:46 +0000
+++ libcontent-hub.pc.in	2014-03-20 13:33:31 +0000
@@ -1,8 +1,11 @@
 prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
+includedir=${prefix}/include
 
 Name: @pkg-name@
 Description: content sharing/picking library
 Version: @CONTENT_HUB_VERSION@
 Libs: -L${libdir} -lcontent-hub
+Cflags: -I${includedir}
+Requires: Qt5DBus

=== modified file 'src/com/ubuntu/content/CMakeLists.txt'
--- src/com/ubuntu/content/CMakeLists.txt	2013-12-06 12:38:33 +0000
+++ src/com/ubuntu/content/CMakeLists.txt	2014-03-20 13:33:31 +0000
@@ -20,6 +20,7 @@
   ${CMAKE_CURRENT_BINARY_DIR}
   ${CMAKE_SOURCE_DIR}/src
   ${CMAKE_SOURCE_DIR}
+  ${CMAKE_SOURCE_DIR}/include
   ${GLIB_INCLUDE_DIRS}
   ${GIO_INCLUDE_DIRS}
   ${NIH_INCLUDE_DIRS}
@@ -91,7 +92,7 @@
   AUTOMOC TRUE
 )
 
-qt5_use_modules(content-hub Core DBus)
+qt5_use_modules(content-hub Core DBus Gui)
 
 target_link_libraries(content-hub
     ${UPSTART_LAUNCH_LDFLAGS}

=== modified file 'src/com/ubuntu/content/detail/app_manager.cpp'
--- src/com/ubuntu/content/detail/app_manager.cpp	2013-12-06 12:36:31 +0000
+++ src/com/ubuntu/content/detail/app_manager.cpp	2014-03-20 13:33:31 +0000
@@ -17,14 +17,17 @@
 #include "app_manager.h"
 
 #include <upstart-app-launch.h>
+#include <QDebug>
 
 namespace cucd = com::ubuntu::content::detail;
 
 /*!
  * \reimp
  */
+
 bool cucd::AppManager::invoke_application(const std::string &app_id)
 {
+    qDebug() << Q_FUNC_INFO << "APP_ID:" << app_id.c_str();
     gchar ** uris = NULL;
     gboolean ok = upstart_app_launch_start_application(app_id.c_str(), (const gchar * const *)uris);
     return static_cast<bool>(ok);
@@ -35,6 +38,8 @@
  */
 bool cucd::AppManager::stop_application(const std::string &app_id)
 {
+    qDebug() << Q_FUNC_INFO << "APP_ID:" << app_id.c_str();
+
     gboolean ok = upstart_app_launch_stop_application(app_id.c_str());
     return static_cast<bool>(ok);
 }

=== modified file 'src/com/ubuntu/content/detail/com.ubuntu.content.Handler.xml'
--- src/com/ubuntu/content/detail/com.ubuntu.content.Handler.xml	2013-08-22 12:48:30 +0000
+++ src/com/ubuntu/content/detail/com.ubuntu.content.Handler.xml	2014-03-20 13:33:31 +0000
@@ -6,5 +6,8 @@
     <method name="HandleExport">
       <arg name="transfer" type="o" direction="in"/>
     </method>
+    <method name="HandleShare">
+      <arg name="transfer" type="o" direction="in"/>
+    </method>
   </interface>
 </node>

=== modified file 'src/com/ubuntu/content/detail/com.ubuntu.content.Service.xml'
--- src/com/ubuntu/content/detail/com.ubuntu.content.Service.xml	2013-09-10 14:11:37 +0000
+++ src/com/ubuntu/content/detail/com.ubuntu.content.Service.xml	2014-03-20 13:33:31 +0000
@@ -2,23 +2,38 @@
   <interface name="com.ubuntu.content.dbus.Service">
     <method name="Quit">
     </method>
-    <method name="DefaultPeerForType">
-      <annotation name="com.trolltech.QtDBus.QtTypeName.In1" value="QVariantMap"/>
-      <arg name="type_id" type="s" direction="in" />
-      <arg name="peer_id" type="s" direction="out" />
-    </method>
-    <method name="KnownPeersForType">
-      <arg name="type_id" type="s" direction="in" />
-      <arg name="peer_ids" type="as" direction="out" />
-    </method>
-    <method name="CreateImportForTypeFromPeer">
-      <arg name="type_id" type="s" direction="in" />
+    <method name="DefaultSourceForType">
+      <arg name="type_id" type="s" direction="in" />
+      <arg name="peer" type="v" direction="out" />
+    </method>
+    <method name="KnownSourcesForType">
+      <arg name="type_id" type="s" direction="in" />
+      <arg name="peers" type="av" direction="out" />
+    </method>
+    <method name="KnownDestinationsForType">
+      <arg name="type_id" type="s" direction="in" />
+      <arg name="peers" type="av" direction="out" />
+    </method>
+    <method name="KnownSharesForType">
+      <arg name="type_id" type="s" direction="in" />
+      <arg name="peers" type="av" direction="out" />
+    </method>
+    <method name="CreateImportFromPeer">
+      <arg name="peer_id" type="s" direction="in" />
+      <arg name="app_id" type="s" direction="in" />
+      <arg name="transfer_object" type="o" direction="out" />
+    </method>
+    <method name="CreateExportToPeer">
+      <arg name="peer_id" type="s" direction="in" />
+      <arg name="app_id" type="s" direction="in" />
+      <arg name="transfer_object" type="o" direction="out" />
+    </method>
+    <method name="CreateShareToPeer">
       <arg name="peer_id" type="s" direction="in" />
       <arg name="app_id" type="s" direction="in" />
       <arg name="transfer_object" type="o" direction="out" />
     </method>
     <method name="RegisterImportExportHandler">
-      <arg name="type_id" type="s" direction="in" />
       <arg name="peer_id" type="s" direction="in" />
       <arg name="handler_object" type="o" direction="in" />
     </method>

=== modified file 'src/com/ubuntu/content/detail/com.ubuntu.content.Transfer.xml'
--- src/com/ubuntu/content/detail/com.ubuntu.content.Transfer.xml	2013-10-01 16:55:39 +0000
+++ src/com/ubuntu/content/detail/com.ubuntu.content.Transfer.xml	2014-03-20 13:33:31 +0000
@@ -41,5 +41,8 @@
     <signal name="SelectionTypeChanged">
       <arg name="selection_type" type="i"/>
     </signal>
+    <method name="Direction">
+      <arg name="direction" type="i" direction="out" />
+    </method>
  </interface>
 </node>

=== modified file 'src/com/ubuntu/content/detail/handler.cpp'
--- src/com/ubuntu/content/detail/handler.cpp	2013-09-09 18:07:14 +0000
+++ src/com/ubuntu/content/detail/handler.cpp	2014-03-20 13:33:31 +0000
@@ -21,6 +21,7 @@
 #include "utils.cpp"
 
 #include <QObject>
+#include <QDebug>
 
 namespace cucd = com::ubuntu::content::detail;
 namespace cuc = com::ubuntu::content;
@@ -48,11 +49,13 @@
     m_handler = handler;
 }
 
-cucd::Handler::~Handler() {}
+cucd::Handler::~Handler() {
+    delete m_handler;
+}
 
 void cucd::Handler::HandleImport(const QDBusObjectPath& transfer)
 {
-    qDebug() << Q_FUNC_INFO;
+    qDebug() << Q_FUNC_INFO << transfer.path();
     cuc::Transfer* t = cuc::Transfer::Private::make_transfer(transfer, this);
 
     qDebug() << Q_FUNC_INFO << "State:" << t->state();
@@ -62,7 +65,7 @@
 
 void cucd::Handler::HandleExport(const QDBusObjectPath& transfer)
 {
-    qDebug() << Q_FUNC_INFO;
+    qDebug() << Q_FUNC_INFO << transfer.path();
     cuc::Transfer* t = cuc::Transfer::Private::make_transfer(transfer, this);
 
     qDebug() << Q_FUNC_INFO << "State:" << t->state();
@@ -72,3 +75,15 @@
         m_handler->handle_export(t);
     }
 }
+
+void cucd::Handler::HandleShare(const QDBusObjectPath& transfer)
+{
+    qDebug() << Q_FUNC_INFO;
+    cuc::Transfer* t = cuc::Transfer::Private::make_transfer(transfer, this);
+
+    qDebug() << Q_FUNC_INFO << "State:" << t->state();
+    if (t->state() == cuc::Transfer::charged)
+    {
+        m_handler->handle_share(t);
+    }
+}

=== modified file 'src/com/ubuntu/content/detail/handler.h'
--- src/com/ubuntu/content/detail/handler.h	2013-09-06 13:18:05 +0000
+++ src/com/ubuntu/content/detail/handler.h	2014-03-20 13:33:31 +0000
@@ -48,6 +48,7 @@
   public Q_SLOTS:
     void HandleImport(const QDBusObjectPath &transfer);
     void HandleExport(const QDBusObjectPath &transfer);
+    void HandleShare(const QDBusObjectPath &transfer);
 
   private:
     struct Private;

=== modified file 'src/com/ubuntu/content/detail/peer_registry.h'
--- src/com/ubuntu/content/detail/peer_registry.h	2013-09-25 03:14:53 +0000
+++ src/com/ubuntu/content/detail/peer_registry.h	2014-03-20 13:33:31 +0000
@@ -40,12 +40,15 @@
 
     PeerRegistry& operator=(const PeerRegistry&) = delete;
 
-    virtual Peer default_peer_for_type(Type) = 0;
-    virtual void enumerate_known_peers_for_type(Type, const std::function<void(const Peer&)>& for_each) = 0;
+    virtual Peer default_source_for_type(Type) = 0;
     virtual void enumerate_known_peers(const std::function<void(const Peer&)>& for_each) = 0;
-
-    virtual bool install_default_peer_for_type(Type, Peer) = 0;
-    virtual bool install_peer_for_type(Type, Peer) = 0;
+    virtual void enumerate_known_sources_for_type(Type, const std::function<void(const Peer&)>& for_each) = 0;
+    virtual void enumerate_known_destinations_for_type(Type, const std::function<void(const Peer&)>& for_each) = 0;
+    virtual void enumerate_known_shares_for_type(Type, const std::function<void(const Peer&)>& for_each) = 0;
+    virtual bool install_default_source_for_type(Type, Peer) = 0;
+    virtual bool install_source_for_type(Type, Peer) = 0;
+    virtual bool install_destination_for_type(Type, Peer) = 0;
+    virtual bool install_share_for_type(Type, Peer) = 0;
     virtual bool remove_peer(Peer peer) = 0;
 
 

=== modified file 'src/com/ubuntu/content/detail/service.cpp'
--- src/com/ubuntu/content/detail/service.cpp	2013-10-10 15:00:36 +0000
+++ src/com/ubuntu/content/detail/service.cpp	2014-03-20 13:33:31 +0000
@@ -22,14 +22,13 @@
 #include "transfer.h"
 #include "transferadaptor.h"
 #include "utils.cpp"
-
-#include "handler.h"
 #include "ContentHandlerInterface.h"
 
 #include <com/ubuntu/content/peer.h>
 #include <com/ubuntu/content/type.h>
 #include <com/ubuntu/content/transfer.h>
 
+#include <QDBusMetaType>
 #include <QCache>
 #include <QCoreApplication>
 #include <QDebug>
@@ -42,6 +41,19 @@
 namespace cucd = com::ubuntu::content::detail;
 namespace cuc = com::ubuntu::content;
 
+struct cucd::Service::RegHandler
+{
+    RegHandler(QString id, QString service, cuc::dbus::Handler* handler) : id(id),
+        service(service),
+        handler(handler)
+    {
+    }
+
+    QString id;
+    QString service;
+    cuc::dbus::Handler* handler;
+};
+
 struct cucd::Service::Private : public QObject
 {
     Private(QDBusConnection connection,
@@ -58,7 +70,9 @@
     QDBusConnection connection;
     QSharedPointer<cucd::PeerRegistry> registry;
     QSet<cucd::Transfer*> active_transfers;
+    QSet<RegHandler*> handlers;
     QSharedPointer<cua::ApplicationManager> app_manager;
+
 };
 
 cucd::Service::Service(QDBusConnection connection, const QSharedPointer<cucd::PeerRegistry>& peer_registry,
@@ -69,11 +83,13 @@
 {
     assert(!peer_registry.isNull());
 
-    m_watcher->setWatchMode(QDBusServiceWatcher::WatchForRegistration);
+    qDBusRegisterMetaType<cuc::Peer>();
+
+    m_watcher->setWatchMode(QDBusServiceWatcher::WatchForUnregistration);
     m_watcher->setConnection(d->connection);
-    QObject::connect(m_watcher, SIGNAL(serviceRegistered(const QString&)),
+    QObject::connect(m_watcher, SIGNAL(serviceUnregistered(const QString&)),
             this,
-            SLOT(handler_registered(const QString&)));
+            SLOT(handler_unregistered(const QString&)));
 }
 
 cucd::Service::~Service()
@@ -86,172 +102,374 @@
     }
 }
 
-void cucd::Service::handler_registered(const QString& name)
-{
-    qDebug() << Q_FUNC_INFO << name;
-    Q_FOREACH (cucd::Transfer *t, d->active_transfers)
-    {
-        if (handler_address(t->source()) == name)
-        {
-            qDebug() << Q_FUNC_INFO << "Found source:" << name;
-            cuc::dbus::Handler *h = new cuc::dbus::Handler(
-                    name,
-                    handler_path(t->source()),
-                    QDBusConnection::sessionBus(),
-                    0);
-            if (h->isValid())
-                h->HandleExport(QDBusObjectPath{t->export_path()});
-        }
-        else if (handler_address(t->destination()) == name)
-        {
-            qDebug() << Q_FUNC_INFO << "Found destination:" << name;
-            cuc::dbus::Handler *h = new cuc::dbus::Handler(
-                    name,
-                    handler_path(t->destination()),
-                    QDBusConnection::sessionBus(),
-                    0);
-            if (h->isValid())
-                h->HandleImport(QDBusObjectPath{t->import_path()});
-        }
-    }
-}
-
 void cucd::Service::Quit()
 {
     QCoreApplication::instance()->quit();
 }
 
-QStringList cucd::Service::KnownPeersForType(const QString& type_id)
-{
-    QStringList result;
-
-    d->registry->enumerate_known_peers_for_type(
-        Type(type_id),
-        [&result](const Peer& peer)
-        {
-            result.append(peer.id());
-        });
-
-    return result;
-}
-
-QString cucd::Service::DefaultPeerForType(const QString& type_id)
-{
-    auto peer = d->registry->default_peer_for_type(Type(type_id));
-
-    return peer.id();
-}
-
-void cucd::Service::connect_export_handler(const QString& peer_id, const QString& transfer)
-{
-    qDebug() << Q_FUNC_INFO;
-
-    cuc::dbus::Handler *h = new cuc::dbus::Handler(
-                handler_address(peer_id),
-                handler_path(peer_id),
-                QDBusConnection::sessionBus(),
-                0);
-
-    qDebug() << Q_FUNC_INFO << "h->isValid:" << h->isValid();
-    if (h->isValid() && (not transfer.isEmpty()))
-        h->HandleExport(QDBusObjectPath{transfer});
-}
-
-void cucd::Service::connect_import_handler(const QString& peer_id, const QString& transfer)
-{
-    qDebug() << Q_FUNC_INFO;
-
-    cuc::dbus::Handler *h = new cuc::dbus::Handler(
-                handler_address(peer_id),
-                handler_path(peer_id),
-                QDBusConnection::sessionBus(),
-                0);
-
-    qDebug() << Q_FUNC_INFO << "h->isValid:" << h->isValid();
-    if (h->isValid() && (not transfer.isEmpty()))
-        h->HandleImport(QDBusObjectPath{transfer});
-}
-
-QDBusObjectPath cucd::Service::CreateImportForTypeFromPeer(const QString& type_id, const QString& peer_id, const QString& dest_id)
-{
-    qDebug() << Q_FUNC_INFO;
+QVariantList cucd::Service::KnownSourcesForType(const QString& type_id)
+{
+    QVariantList result;
+
+    d->registry->enumerate_known_sources_for_type(
+        Type(type_id),
+        [&result](const Peer& peer)
+        {
+            result.append(QVariant::fromValue(peer));
+        });
+
+    return result;
+}
+
+QVariantList cucd::Service::KnownDestinationsForType(const QString& type_id)
+{
+    QVariantList result;
+
+    d->registry->enumerate_known_destinations_for_type(
+        Type(type_id),
+        [&result](const Peer& peer)
+        {
+            result.append(QVariant::fromValue(peer));
+        });
+
+    return result;
+}
+
+QVariantList cucd::Service::KnownSharesForType(const QString& type_id)
+{
+    QVariantList result;
+
+    d->registry->enumerate_known_shares_for_type(
+        Type(type_id),
+        [&result](const Peer& peer)
+        {
+            result.append(QVariant::fromValue(peer));
+        });
+
+    return result;
+}
+
+QDBusVariant cucd::Service::DefaultSourceForType(const QString& type_id)
+{
+    cuc::Peer peer = d->registry->default_source_for_type(Type(type_id));
+
+    return QDBusVariant(QVariant::fromValue(peer));
+}
+
+QDBusObjectPath cucd::Service::CreateImportFromPeer(const QString& peer_id, const QString& app_id)
+{
+    qDebug() << Q_FUNC_INFO;
+    QString dest_id = app_id;
+    if (dest_id.isEmpty())
+    {
+        qDebug() << Q_FUNC_INFO << "APP_ID isnt' set, attempting to get it from AppArmor";
+        dest_id = aa_profile(this->message().service());
+    }
+    return CreateTransfer(dest_id, peer_id, cuc::Transfer::Import);
+}
+
+bool cucd::Service::should_cancel (int st)
+{
+    qDebug() << Q_FUNC_INFO << "State:" << st;
+
+    return (st != cuc::Transfer::finalized
+            && st != cuc::Transfer::collected
+            && st != cuc::Transfer::aborted);
+}
+
+QDBusObjectPath cucd::Service::CreateExportToPeer(const QString& peer_id, const QString& app_id)
+{
+    qDebug() << Q_FUNC_INFO;
+    QString src_id = app_id;
+    if (src_id.isEmpty())
+    {
+        qDebug() << Q_FUNC_INFO << "APP_ID isnt' set, attempting to get it from AppArmor";
+        src_id = aa_profile(this->message().service());
+    }
+    return CreateTransfer(peer_id, src_id, cuc::Transfer::Export);
+}
+
+QDBusObjectPath cucd::Service::CreateShareToPeer(const QString& peer_id, const QString& app_id)
+{
+    qDebug() << Q_FUNC_INFO;
+    QString src_id = app_id;
+    if (src_id.isEmpty())
+    {
+        qDebug() << Q_FUNC_INFO << "APP_ID isnt' set, attempting to get it from AppArmor";
+        src_id = aa_profile(this->message().service());
+    }
+    return CreateTransfer(peer_id, src_id, cuc::Transfer::Share);
+}
+
+QDBusObjectPath cucd::Service::CreateTransfer(const QString& dest_id, const QString& src_id, int dir)
+{
+    qDebug() << Q_FUNC_INFO << "DEST:" << dest_id << "SRC:" << src_id << "DIRECTION:" << dir;
 
     static size_t import_counter{0}; import_counter++;
 
-    QString app_id = dest_id;
-    if (app_id.isEmpty())
-    {
-        qDebug() << Q_FUNC_INFO << "APP_ID isnt' set, attempting to get it from AppArmor";
-        app_id = aa_profile(this->message().service());
-    }
-
-    qDebug() << Q_FUNC_INFO << "APP_ID:" << app_id;
-
     QUuid uuid{QUuid::createUuid()};
 
-    auto transfer = new cucd::Transfer(import_counter, peer_id, app_id, this);
+    Q_FOREACH (cucd::Transfer *t, d->active_transfers)
+    {
+        if (t->destination() == dest_id || t->source() == src_id)
+        {
+            qDebug() << Q_FUNC_INFO << "Found transfer for peer_id:" << src_id;
+            if (should_cancel(t->State()))
+            {
+                qDebug() << Q_FUNC_INFO << "Aborting active transfer:" << t->Id();
+                t->Abort();
+            }
+        }
+    }
+
+    auto transfer = new cucd::Transfer(import_counter, src_id, dest_id, dir, this);
     new TransferAdaptor(transfer);
     d->active_transfers.insert(transfer);
 
     auto destination = transfer->import_path();
     auto source = transfer->export_path();
-    if (not d->connection.registerObject(destination, transfer))
-        qDebug() << "Problem registering object for path: " << destination;
-    d->connection.registerObject(source, transfer);
+    if (not d->connection.registerObject(source, transfer))
+        qDebug() << "Problem registering object for path: " << source;
+    d->connection.registerObject(destination, transfer);
 
     qDebug() << "Created transfer " << source << " -> " << destination;
 
-    connect(transfer, SIGNAL(StateChanged(int)), this, SLOT(handle_transfer(int)));
-
-    /* watch for handlers */
-    m_watcher->addWatchedService(handler_address(peer_id));
-    qDebug() << Q_FUNC_INFO << "Watches:" << m_watcher->watchedServices();
-    this->connect_export_handler(peer_id, source);
-    this->connect_import_handler(app_id, destination);
-
-    Q_UNUSED(type_id);
-
-    return QDBusObjectPath{destination};
-}
-
-void cucd::Service::handle_transfer(int state)
+    // Content flow is different for import
+    if (dir == cuc::Transfer::Import)
+    {
+        connect(transfer, SIGNAL(StateChanged(int)), this, SLOT(handle_imports(int)));
+        return QDBusObjectPath{destination};
+    }
+
+    connect(transfer, SIGNAL(StateChanged(int)), this, SLOT(handle_exports(int)));
+    return QDBusObjectPath{source};
+}
+
+void cucd::Service::handle_imports(int state)
+{
+    qDebug() << Q_FUNC_INFO << state;
+    cucd::Transfer *transfer = static_cast<cucd::Transfer*>(sender());
+    qDebug() << Q_FUNC_INFO << "State: " << transfer->State() << "Id:" << transfer->Id();
+
+    if (state == cuc::Transfer::initiated)
+    {
+        qDebug() << Q_FUNC_INFO << "initiated";
+        if (d->app_manager->is_application_started(transfer->source().toStdString()))
+            transfer->SetSourceStartedByContentHub(false);
+        else
+            transfer->SetSourceStartedByContentHub(true);
+
+        Q_FOREACH (RegHandler *r, d->handlers)
+        {
+            qDebug() << Q_FUNC_INFO << "ID:" << r->id << "Handler: " << r->service << "Transfer: " << transfer->source();
+            if (r->id == transfer->source())
+            {
+                qDebug() << Q_FUNC_INFO << "Found handler for initiated transfer" << r->id;
+                if (r->handler->isValid())
+                    r->handler->HandleExport(QDBusObjectPath{transfer->export_path()});
+                else
+                    qDebug() << Q_FUNC_INFO << "Handler invalid";
+            }
+        }
+
+        d->app_manager->invoke_application(transfer->source().toStdString());
+    }
+
+    if (state == cuc::Transfer::charged)
+    {
+        qDebug() << Q_FUNC_INFO << "Charged";
+        if (transfer->WasSourceStartedByContentHub())
+            d->app_manager->stop_application(transfer->source().toStdString());
+        
+        d->app_manager->invoke_application(transfer->destination().toStdString());
+
+        Q_FOREACH (RegHandler *r, d->handlers)
+        {
+            qDebug() << Q_FUNC_INFO << "ID:" << r->id << "Handler: " << r->service << "Transfer: " << transfer->destination();
+            if (r->id == transfer->destination())
+            {
+                qDebug() << Q_FUNC_INFO << "Found handler for charged transfer" << r->id;
+                if (r->handler->isValid())
+                    r->handler->HandleImport(QDBusObjectPath{transfer->import_path()});
+            }
+        }
+    }
+
+    if (state == cuc::Transfer::aborted)
+    {
+        if (transfer->WasSourceStartedByContentHub())
+        {
+            bool shouldStop = true;
+            Q_FOREACH (cucd::Transfer *t, d->active_transfers)
+            {
+                if (t->Id() != transfer->Id())
+                {
+                    if ((t->source() == transfer->source()) || (t->destination() == transfer->destination()))
+                    {
+                        qDebug() << Q_FUNC_INFO << "Peer has pending transfers:" << t->Id();
+                        shouldStop = false;
+                    }
+                }
+            }
+            if (shouldStop)
+            {
+                d->app_manager->stop_application(transfer->source().toStdString());
+                d->app_manager->invoke_application(transfer->destination().toStdString());
+            }
+        }
+    }
+}
+
+void cucd::Service::handle_exports(int state)
 {
     qDebug() << Q_FUNC_INFO;
     cucd::Transfer *transfer = static_cast<cucd::Transfer*>(sender());
 
+    qDebug() << Q_FUNC_INFO << "STATE:" << transfer->State();
+
+
     if (state == cuc::Transfer::initiated)
     {
         qDebug() << Q_FUNC_INFO << "Initiated";
-        if (d->app_manager->is_application_started(transfer->source().toStdString()))
+        transfer->Handled();
+    }
+
+    if (state == cuc::Transfer::charged)
+    {
+        qDebug() << Q_FUNC_INFO << "Charged";
+        if (d->app_manager->is_application_started(transfer->destination().toStdString()))
             transfer->SetSourceStartedByContentHub(false);
         else
             transfer->SetSourceStartedByContentHub(true);
 
+        d->app_manager->invoke_application(transfer->destination().toStdString());
+
+        Q_FOREACH (RegHandler *r, d->handlers)
+        {
+            qDebug() << "Handler: " << r->service << "Transfer: " << transfer->destination();
+            if (r->id == transfer->destination())
+            {
+                qDebug() << "Found handler for charged transfer" << r->id;
+                if (transfer->Direction() == cuc::Transfer::Share && r->handler->isValid())
+                    r->handler->HandleShare(QDBusObjectPath{transfer->import_path()});
+                else if (r->handler->isValid())
+                    r->handler->HandleImport(QDBusObjectPath{transfer->import_path()});
+            }
+        }
+    }
+
+    if (state == cuc::Transfer::finalized)
+    {
+        qDebug() << Q_FUNC_INFO << "Finalized";
+        if (transfer->WasSourceStartedByContentHub())
+            d->app_manager->stop_application(transfer->destination().toStdString());
+
         d->app_manager->invoke_application(transfer->source().toStdString());
-        this->connect_export_handler(transfer->source(), transfer->export_path());
-    }
-
-    if (state == cuc::Transfer::charged)
-    {
-        qDebug() << Q_FUNC_INFO << "Charged";
-        d->app_manager->invoke_application(transfer->destination().toStdString());
-
-        if (transfer->WasSourceStartedByContentHub())
-            d->app_manager->stop_application(transfer->source().toStdString());
-
-        this->connect_import_handler(transfer->destination(), transfer->import_path());
     }
 
     if (state == cuc::Transfer::aborted)
     {
-        d->app_manager->invoke_application(transfer->destination().toStdString());
-
+        qDebug() << Q_FUNC_INFO << "Aborted";
         if (transfer->WasSourceStartedByContentHub())
-            d->app_manager->stop_application(transfer->source().toStdString());
-    }
-}
-
-void cucd::Service::RegisterImportExportHandler(const QString& /*type_id*/, const QString& peer_id, const QDBusObjectPath& handler)
-{
-    qDebug() << Q_FUNC_INFO << peer_id << ":" << handler.path();
+        {
+            bool shouldStop = true;
+            Q_FOREACH (cucd::Transfer *t, d->active_transfers)
+            {
+                if (t->Id() != transfer->Id())
+                {
+                    if ((t->source() == transfer->source()) || (t->destination() == transfer->destination()))
+                    {
+                        qDebug() << Q_FUNC_INFO << "Peer has pending transfers:" << t->Id();
+                        shouldStop = false;
+                    }
+                }
+            }
+            if (shouldStop)
+            {
+                d->app_manager->stop_application(transfer->destination().toStdString());
+                d->app_manager->invoke_application(transfer->source().toStdString());
+            }
+        }
+    }
+}
+
+void cucd::Service::handler_unregistered(const QString& s)
+{
+    qDebug() << Q_FUNC_INFO << s;
+
+    if (d->handlers.isEmpty())
+        return;
+
+    Q_FOREACH (RegHandler *r, d->handlers)
+    {
+        qDebug() << "Handler: " << r->id;
+        if (r->service == s)
+        {
+            qDebug() << "Found match for " << r->id;
+            d->handlers.remove(r);
+            m_watcher->removeWatchedService(s);
+            delete r;
+        }
+    }
+}
+
+void cucd::Service::RegisterImportExportHandler(const QString& peer_id, const QDBusObjectPath& handler)
+{
+    qDebug() << Q_FUNC_INFO << peer_id;
+    bool exists = false;
+    RegHandler* r;
+    Q_FOREACH (RegHandler *rh, d->handlers)
+    {
+        qDebug() << "Handler: " << rh->id;
+        if (rh->id == peer_id)
+        {
+            qDebug() << "Found existing handler for " << rh->id;
+            exists = true;
+            r = rh;
+        }
+    }
+
+    if (!exists)
+    {
+        r = new RegHandler{peer_id,
+            this->message().service(),
+            new cuc::dbus::Handler(
+                    this->message().service(),
+                    handler.path(),
+                    QDBusConnection::sessionBus(),
+                    0)};
+        d->handlers.insert(r);
+        m_watcher->addWatchedService(r->service);
+    }
+
+    qDebug() << Q_FUNC_INFO << r->id;
+
+    Q_FOREACH (cucd::Transfer *t, d->active_transfers)
+    {
+        qDebug() << Q_FUNC_INFO << "SOURCE: " << t->source() << "DEST:" << t->destination() << "STATE:" << t->State();
+        if ((t->source() == peer_id) && (t->State() == cuc::Transfer::initiated))
+        {
+            qDebug() << Q_FUNC_INFO << "Found source:" << peer_id << "Direction:" << t->Direction();
+            if (t->Direction() == cuc::Transfer::Import)
+            {
+                if (r->handler->isValid())
+                    r->handler->HandleExport(QDBusObjectPath{t->export_path()});
+            }
+        }
+        else if ((t->destination() == peer_id) && (t->State() == cuc::Transfer::charged))
+        {
+            qDebug() << Q_FUNC_INFO << "Found destination:" << peer_id << "Direction:" << t->Direction();
+            if (t->Direction() == cuc::Transfer::Export)
+            {
+                qDebug() << Q_FUNC_INFO << "Found import, calling HandleImport";
+                if (r->handler->isValid())
+                    r->handler->HandleImport(QDBusObjectPath{t->import_path()});
+            } else if (t->Direction() == cuc::Transfer::Share)
+            {
+                qDebug() << Q_FUNC_INFO << "Found share, calling HandleShare";
+                if (r->handler->isValid())
+                    r->handler->HandleShare(QDBusObjectPath{t->import_path()});
+            }
+        }
+    }
 }

=== modified file 'src/com/ubuntu/content/detail/service.h'
--- src/com/ubuntu/content/detail/service.h	2013-09-13 16:02:49 +0000
+++ src/com/ubuntu/content/detail/service.h	2014-03-20 13:33:31 +0000
@@ -53,22 +53,29 @@
     Service& operator=(const Service&) = delete;
 
   public Q_SLOTS:
-    QString DefaultPeerForType(const QString &type_id);
-    QStringList KnownPeersForType(const QString &type_id);
-    QDBusObjectPath CreateImportForTypeFromPeer(const QString&, const QString&, const QString&);
-    void RegisterImportExportHandler(const QString&, const QString&, const QDBusObjectPath& handler);
+    QDBusVariant DefaultSourceForType(const QString &type_id);
+    QVariantList KnownSourcesForType(const QString &type_id);
+    QVariantList KnownDestinationsForType(const QString &type_id);
+    QVariantList KnownSharesForType(const QString &type_id);
+    QDBusObjectPath CreateImportFromPeer(const QString&, const QString&);
+    QDBusObjectPath CreateExportToPeer(const QString&, const QString&);
+    QDBusObjectPath CreateShareToPeer(const QString&, const QString&);
+
+    void RegisterImportExportHandler(const QString&, const QDBusObjectPath& handler);
     void Quit();
 
   private:
+    bool should_cancel(int);
     struct Private;
+    struct RegHandler;
     QDBusServiceWatcher* m_watcher;
     QScopedPointer<Private> d;
-    void connect_export_handler(const QString&, const QString&);
-    void connect_import_handler(const QString&, const QString&);
 
   private Q_SLOTS:
-    void handle_transfer(int);
-    void handler_registered(const QString&);
+    void handle_imports(int);
+    void handle_exports(int);
+    void handler_unregistered(const QString&);
+    QDBusObjectPath CreateTransfer(const QString&, const QString&, int);
 
 };
 }

=== modified file 'src/com/ubuntu/content/detail/transfer.cpp'
--- src/com/ubuntu/content/detail/transfer.cpp	2013-10-10 15:00:36 +0000
+++ src/com/ubuntu/content/detail/transfer.cpp	2014-03-20 13:33:31 +0000
@@ -32,11 +32,13 @@
 {
     Private(const int id,
             const QString& source,
-            const QString& destination) :
+            const QString& destination,
+            const int direction)    :
         state(cuc::Transfer::created),
             id(id),
             source(source),
             destination(destination),
+            direction(direction),
             selection_type(cuc::Transfer::single),
             source_started_by_content_hub(false)
     {
@@ -46,6 +48,7 @@
     const int id;
     const QString source;
     const QString destination;
+    int direction;
     QString store;
     int selection_type;
     QStringList items;
@@ -55,8 +58,9 @@
 cucd::Transfer::Transfer(const int id,
                          const QString& source,
                          const QString& destination,
+                         const int direction,
                          QObject* parent) :
-    QObject(parent), d(new Private(id, source, destination))
+    QObject(parent), d(new Private(id, source, destination, direction))
 {
     qDebug() << __PRETTY_FUNCTION__;
 }
@@ -88,6 +92,12 @@
     return d->destination;
 }
 
+int cucd::Transfer::Direction()
+{
+    qDebug() << __PRETTY_FUNCTION__;
+    return d->direction;
+}
+
 int cucd::Transfer::State()
 {
     qDebug() << __PRETTY_FUNCTION__;

=== modified file 'src/com/ubuntu/content/detail/transfer.h'
--- src/com/ubuntu/content/detail/transfer.h	2013-10-10 15:00:36 +0000
+++ src/com/ubuntu/content/detail/transfer.h	2014-03-20 13:33:31 +0000
@@ -38,9 +38,10 @@
     Q_PROPERTY(int id READ Id)
     Q_PROPERTY(QString source READ source)
     Q_PROPERTY(QString destination READ destination)
+    Q_PROPERTY(int direction READ Direction)
 
   public:
-    Transfer(const int, const QString&, const QString&, QObject* parent = nullptr);
+    Transfer(const int, const QString&, const QString&, const int, QObject* parent = nullptr);
     Transfer(const Transfer&) = delete;
     virtual ~Transfer();
 
@@ -67,6 +68,7 @@
     int SelectionType();
     void SetSelectionType(int);
     int Id();
+    int Direction();
     QString source();
     QString destination();
     QString export_path();

=== modified file 'src/com/ubuntu/content/hub.cpp'
--- src/com/ubuntu/content/hub.cpp	2013-10-01 16:55:39 +0000
+++ src/com/ubuntu/content/hub.cpp	2014-03-20 13:33:31 +0000
@@ -74,27 +74,19 @@
         return;
     }
 
-    QString bus_name = handler_address(id);
-    qDebug() << Q_FUNC_INFO << "BUS_NAME:" << bus_name;
-
     auto c = QDBusConnection::sessionBus();
     auto h = new cuc::detail::Handler(c, id, handler);
 
     new HandlerAdaptor(h);
-    if (not c.registerService(bus_name))
-    {
-        qWarning() << Q_FUNC_INFO << "Failed to register name:" << bus_name;
-        return;
-    }
+
 
     if (not c.registerObject(handler_path(id), h))
     {
-        qWarning() << Q_FUNC_INFO << "Failed to register object for:" << bus_name;
+        qWarning() << Q_FUNC_INFO << "Failed to register object for:" << id;
         return;
     }
 
     d->service->RegisterImportExportHandler(
-                QString(""),
                 id,
                 QDBusObjectPath{handler_path(id)});
 }
@@ -122,43 +114,82 @@
     return it->second;
 }
 
-cuc::Peer cuc::Hub::default_peer_for_type(cuc::Type t)
+cuc::Peer cuc::Hub::default_source_for_type(cuc::Type t)
 {
-    auto reply = d->service->DefaultPeerForType(t.id());
+    qDebug() << Q_FUNC_INFO;
+    auto reply = d->service->DefaultSourceForType(t.id());
     reply.waitForFinished();
 
     if (reply.isError())
         return cuc::Peer::unknown();
 
-    return cuc::Peer(reply.value(), this);
+    auto peer = reply.value();
+    return qdbus_cast<cuc::Peer>(peer.variant());
 }
 
-QVector<cuc::Peer> cuc::Hub::known_peers_for_type(cuc::Type t)
+QVector<cuc::Peer> cuc::Hub::known_sources_for_type(cuc::Type t)
 {
     QVector<cuc::Peer> result;
 
-    auto reply = d->service->KnownPeersForType(t.id());
+    auto reply = d->service->KnownSourcesForType(t.id());
     reply.waitForFinished();
 
     if (reply.isError())
         return result;
     
-    auto ids = reply.value();
-
-    Q_FOREACH(const QString& id, ids)
-    {
-        result << cuc::Peer(id, this);
-    }
-
-    return result;
-}
-
-cuc::Transfer* cuc::Hub::create_import_for_type_from_peer(cuc::Type type, cuc::Peer peer)
+    auto peers = reply.value();
+
+    Q_FOREACH(const QVariant& p, peers)
+    {
+        result << qdbus_cast<cuc::Peer>(p);
+    }
+    return result;
+}
+
+QVector<cuc::Peer> cuc::Hub::known_destinations_for_type(cuc::Type t)
+{
+    QVector<cuc::Peer> result;
+
+    auto reply = d->service->KnownDestinationsForType(t.id());
+    reply.waitForFinished();
+
+    if (reply.isError())
+        return result;
+
+    auto peers = reply.value();
+
+    Q_FOREACH(const QVariant& p, peers)
+    {
+        result << qdbus_cast<cuc::Peer>(p);
+    }
+    return result;
+}
+
+QVector<cuc::Peer> cuc::Hub::known_shares_for_type(cuc::Type t)
+{
+    QVector<cuc::Peer> result;
+
+    auto reply = d->service->KnownSharesForType(t.id());
+    reply.waitForFinished();
+
+    if (reply.isError())
+        return result;
+
+    auto peers = reply.value();
+
+    Q_FOREACH(const QVariant& p, peers)
+    {
+        result << qdbus_cast<cuc::Peer>(p);
+    }
+    return result;
+}
+
+cuc::Transfer* cuc::Hub::create_import_from_peer(cuc::Peer peer)
 {
     /* This needs to be replaced with a better way to get the APP_ID */
     QString id = app_id();
 
-    auto reply = d->service->CreateImportForTypeFromPeer(type.id(), peer.id(), id);
+    auto reply = d->service->CreateImportFromPeer(peer.id(), id);
     reply.waitForFinished();
 
     if (reply.isError())
@@ -170,6 +201,49 @@
     return transfer;
 }
 
+cuc::Transfer* cuc::Hub::create_export_to_peer(cuc::Peer peer)
+{
+    /* This needs to be replaced with a better way to get the APP_ID */
+    QString id = app_id();
+
+    auto reply = d->service->CreateExportToPeer(peer.id(), id);
+    reply.waitForFinished();
+
+    if (reply.isError())
+        return nullptr;
+
+    cuc::Transfer *transfer = cuc::Transfer::Private::make_transfer(reply.value(), this);
+
+    QString peerName = peer.id().split("_")[0];
+    qDebug() << Q_FUNC_INFO << "peerName: " << peerName;
+    const cuc::Store *store = new cuc::Store{QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + "/" + peerName + "/HubIncoming/" + QString::number(transfer->id()), this};
+    qDebug() << Q_FUNC_INFO << "STORE:" << store->uri();
+    transfer->setStore(store);
+    transfer->start();
+    return transfer;
+}
+
+cuc::Transfer* cuc::Hub::create_share_to_peer(cuc::Peer peer)
+{
+    /* This needs to be replaced with a better way to get the APP_ID */
+    QString id = app_id();
+
+    auto reply = d->service->CreateShareToPeer(peer.id(), id);
+    reply.waitForFinished();
+
+    if (reply.isError())
+        return nullptr;
+
+    cuc::Transfer *transfer = cuc::Transfer::Private::make_transfer(reply.value(), this);
+    QString peerName = peer.id().split("_")[0];
+    qDebug() << Q_FUNC_INFO << "peerName: " << peerName;
+    const cuc::Store *store = new cuc::Store{QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + "/" + peerName + "/HubIncoming/" + QString::number(transfer->id()), this};
+    qDebug() << Q_FUNC_INFO << "STORE:" << store->uri();
+    transfer->setStore(store);
+    transfer->start();
+    return transfer;
+}
+
 void cuc::Hub::quit()
 {
     d->service->Quit();

=== modified file 'src/com/ubuntu/content/peer.cpp'
--- src/com/ubuntu/content/peer.cpp	2013-10-01 16:55:39 +0000
+++ src/com/ubuntu/content/peer.cpp	2014-03-20 13:33:31 +0000
@@ -16,14 +16,49 @@
  * Authored by: Thomas Voß <[e-mail]>
  */
 
+
 #include <gio/gdesktopappinfo.h>
 #include <com/ubuntu/content/peer.h>
+#include <QMetaType>
 
 namespace cuc = com::ubuntu::content;
 
 struct cuc::Peer::Private
 {
+    Private (QString id, bool isDefaultPeer) : id(id), isDefaultPeer(isDefaultPeer)
+    {
+        qDebug() << Q_FUNC_INFO << id;
+        if (name.isEmpty())
+        {
+            QString desktop_id(id + ".desktop");
+            GDesktopAppInfo* app = g_desktop_app_info_new(desktop_id.toLocal8Bit().data());
+            if (G_IS_APP_INFO(app))
+            {
+                name = QString::fromLatin1(g_app_info_get_display_name(G_APP_INFO(app)));
+                GIcon* ic = g_app_info_get_icon(G_APP_INFO(app));
+                if (G_IS_ICON(ic))
+                {
+                    iconName = QString::fromUtf8(g_icon_to_string(ic));
+                    if (QFile::exists(iconName)) {
+                        QFile iconFile(iconName);
+                        if(iconFile.open(QIODevice::ReadOnly)) {
+                            iconData = iconFile.readAll();
+                            iconFile.close();
+                        }
+                    }
+                    g_object_unref(ic);
+                }
+
+                g_object_unref(app);
+            }
+        }
+    }
+
     QString id;
+    QString name;
+    QByteArray iconData;
+    QString iconName;
+    bool isDefaultPeer;
 };
 
 const cuc::Peer& cuc::Peer::unknown()
@@ -32,8 +67,9 @@
     return peer;
 }
 
-cuc::Peer::Peer(const QString& id, QObject* parent) : QObject(parent), d(new cuc::Peer::Private{id})
+cuc::Peer::Peer(const QString& id, bool isDefaultPeer, QObject* parent) : QObject(parent), d(new cuc::Peer::Private{id, isDefaultPeer})
 {
+    qDebug() << Q_FUNC_INFO;
 }
 
 cuc::Peer::Peer(const cuc::Peer& rhs) : QObject(rhs.parent()), d(rhs.d)
@@ -63,11 +99,68 @@
     return d->id;
 }
 
-QString cuc::Peer::name()
-{
-    QString desktop_id(d->id + ".desktop");
-    GDesktopAppInfo* app = g_desktop_app_info_new(desktop_id.toLocal8Bit().data());
-    QString display_name = QString::fromLatin1(g_app_info_get_display_name(G_APP_INFO(app)));
-    g_object_unref(app);
-    return display_name;
+QString cuc::Peer::name() const
+{
+    return d->name;
+}
+
+void cuc::Peer::setName(const QString& name)
+{
+    if (name != d->name)
+        d->name = name;
+}
+
+QByteArray cuc::Peer::iconData() const
+{
+    return d->iconData;
+}
+
+void cuc::Peer::setIconData(const QByteArray& iconData)
+{
+    if (iconData != d->iconData)
+        d->iconData = iconData;
+}
+
+QString cuc::Peer::iconName() const
+{
+    return d->iconName;
+}
+
+void cuc::Peer::setIconName(const QString& iconName)
+{
+    if (iconName != d->iconName)
+        d->iconName = iconName;
+}
+
+bool cuc::Peer::isDefaultPeer() const
+{
+    return d->isDefaultPeer;
+}
+
+QDBusArgument &operator<<(QDBusArgument &argument, const cuc::Peer& peer)
+{
+    argument.beginStructure();
+    argument << peer.id() << peer.name() << peer.iconData() << peer.iconName() << peer.isDefaultPeer();
+    argument.endStructure();
+    return argument;
+}
+
+const QDBusArgument &operator>>(const QDBusArgument &argument, cuc::Peer &peer)
+{
+    qDebug() << Q_FUNC_INFO;
+    QString id;
+    QString name;
+    QByteArray ic;
+    QString iconName;
+    bool isDefaultPeer;
+
+    argument.beginStructure();
+    argument >> id >> name >> ic >> iconName >> isDefaultPeer;
+    argument.endStructure();
+
+    peer = cuc::Peer{id, isDefaultPeer};
+    peer.setName(name);
+    peer.setIconData(ic);
+    peer.setIconName(iconName);
+    return argument;
 }

=== modified file 'src/com/ubuntu/content/service/CMakeLists.txt'
--- src/com/ubuntu/content/service/CMakeLists.txt	2014-01-29 19:39:49 +0000
+++ src/com/ubuntu/content/service/CMakeLists.txt	2014-03-20 13:33:31 +0000
@@ -35,7 +35,7 @@
   ${CONTENT_SERVICE_SKELETON}
 )
 
-qt5_use_modules(content-hub-service Core DBus)
+qt5_use_modules(content-hub-service Core DBus Gui)
 
 target_link_libraries(
   content-hub-service
@@ -69,7 +69,7 @@
   hook.cpp
 )
 
-qt5_use_modules(content-hub-peer-hook Core)
+qt5_use_modules(content-hub-peer-hook Core Gui DBus)
 
 target_link_libraries(
   content-hub-peer-hook
@@ -94,7 +94,6 @@
 "${CMAKE_CURRENT_BINARY_DIR}/content-hub.hook"
 )
 
-set(pkglibexecdir "${CMAKE_INSTALL_FULL_LIBEXECDIR}")
 configure_file("content-hub.hook.in"
   "${CLICK_HOOK}"
   @ONLY

=== modified file 'src/com/ubuntu/content/service/com.ubuntu.content.hub.gschema.xml'
--- src/com/ubuntu/content/service/com.ubuntu.content.hub.gschema.xml	2014-01-29 19:24:02 +0000
+++ src/com/ubuntu/content/service/com.ubuntu.content.hub.gschema.xml	2014-03-20 13:33:31 +0000
@@ -11,10 +11,38 @@
       <default>[]</default>
     </key>
     <key name="contacts" type="as">
-      <default>[]</default>
-    </key>
-  </schema>
-  <schema id="com.ubuntu.content.hub.all" path="/com/ubuntu/content/hub/peers/">
+      <default>["com.ubuntu.address-book", "address-book", "current-user-version"]</default>
+    </key>
+  </schema>
+  <schema id="com.ubuntu.content.hub.source" path="/com/ubuntu/content/hub/source/">
+    <key name="pictures" type="as">
+      <default>[]</default>
+    </key>
+    <key name="music" type="as">
+      <default>[]</default>
+    </key>
+    <key name="documents" type="as">
+      <default>[]</default>
+    </key>
+    <key name="contacts" type="as">
+      <default>[]</default>
+    </key>
+  </schema>
+  <schema id="com.ubuntu.content.hub.destination" path="/com/ubuntu/content/hub/destination/">
+    <key name="pictures" type="as">
+      <default>[]</default>
+    </key>
+    <key name="music" type="as">
+      <default>[]</default>
+    </key>
+    <key name="documents" type="as">
+      <default>[]</default>
+    </key>
+    <key name="contacts" type="as">
+      <default>[]</default>
+    </key>
+  </schema>
+  <schema id="com.ubuntu.content.hub.share" path="/com/ubuntu/content/hub/share/">
     <key name="pictures" type="as">
       <default>[]</default>
     </key>

=== modified file 'src/com/ubuntu/content/service/helper.cpp'
--- src/com/ubuntu/content/service/helper.cpp	2013-09-23 20:30:18 +0000
+++ src/com/ubuntu/content/service/helper.cpp	2014-03-20 13:33:31 +0000
@@ -34,7 +34,7 @@
             return 1;
     }
 
-    new Hook();
+    new cuc::detail::Hook();
 
     app.exec();
 

=== modified file 'src/com/ubuntu/content/service/hook.cpp'
--- src/com/ubuntu/content/service/hook.cpp	2013-12-10 15:59:15 +0000
+++ src/com/ubuntu/content/service/hook.cpp	2014-03-20 13:33:31 +0000
@@ -28,21 +28,22 @@
 
 #include "hook.h"
 
-Hook::Hook(QObject *parent) :
+namespace cucd = com::ubuntu::content::detail;
+
+cucd::Hook::Hook(QObject *parent) :
     QObject(parent),
     registry(new Registry())
 {
     QTimer::singleShot(200, this, SLOT(run()));
 }
 
-
-Hook::Hook(com::ubuntu::content::detail::PeerRegistry *registry, QObject *parent) :
+cucd::Hook::Hook(com::ubuntu::content::detail::PeerRegistry *registry, QObject *parent) :
     QObject(parent),
     registry(registry)
 {
 }
 
-void Hook::run()
+void cucd::Hook::run()
 {
     qDebug() << Q_FUNC_INFO;
     /* Looks for files in ${HOME}/.local/share/content-hub/${id} installed
@@ -87,10 +88,12 @@
     QCoreApplication::instance()->quit();
 }
 
-bool Hook::add_peer(QFileInfo result)
+bool cucd::Hook::add_peer(QFileInfo result)
 {
     qDebug() << Q_FUNC_INFO << "Hook:" << result.filePath();
 
+    QStringList knownTypes;
+    knownTypes << "pictures" << "music" << "contacts" << "documents";
     QString app_id = result.fileName();
     auto peer = cuc::Peer(app_id);
 
@@ -109,35 +112,44 @@
 
     QJsonObject contentObj = contentDoc.object();
     QVariant sources = contentObj.toVariantMap()["source"];
-    Q_FOREACH(QString source, sources.toStringList())
-    {
-        /* FIXME: we should iterate known types, but there isn't
-         * really a good way to do that right now */
-        if (source == "pictures")
-        {
-            if (not registry->install_peer_for_type(cuc::Type::Known::pictures(), peer))
-                qWarning() << "Failed to install peer for" << source;
-        }
-        else if (source == "music")
-        {
-            if (not registry->install_peer_for_type(cuc::Type::Known::music(), peer))
-                qWarning() << "Failed to install peer for" << source;
-        }
-        else if (source == "documents")
-        {
-            if (not registry->install_peer_for_type(cuc::Type::Known::documents(), peer))
-                qWarning() << "Failed to install peer for" << source;
-        }
-        else if (source == "contacts")
-        {
-            if (not registry->install_peer_for_type(cuc::Type::Known::contacts(), peer))
-                qWarning() << "Failed to install peer for" << source;
-        }
+    Q_FOREACH(QString k, sources.toStringList())
+    {
+        if (knownTypes.contains(k))
+        {
+            if (registry->install_source_for_type(cuc::Type{k}, peer))
+                qDebug() << "Installed source:" << peer.id() << "for type:" << k;
+        }
+        else
+            qWarning() << "Failed to install" << peer.id() << "unknown type:" << k;
+    }
+
+    QVariant dests = contentObj.toVariantMap()["destination"];
+    Q_FOREACH(QString k, dests.toStringList())
+    {
+        if (knownTypes.contains(k))
+        {
+            if (registry->install_destination_for_type(cuc::Type{k}, peer))
+                qDebug() << "Installed destination:" << peer.id() << "for type:" << k;
+        }
+        else
+            qWarning() << "Failed to install" << peer.id() << "unknown type:" << k;
+    }
+
+    QVariant shares = contentObj.toVariantMap()["share"];
+    Q_FOREACH(QString k, shares.toStringList())
+    {
+        if (knownTypes.contains(k))
+        {
+            if (registry->install_share_for_type(cuc::Type{k}, peer))
+                qDebug() << "Installed share:" << peer.id() << "for type:" << k;
+        }
+        else
+            qWarning() << "Failed to install" << peer.id() << "unknown type:" << k;
     }
     return true;
 }
 
-bool Hook::return_error(QString err)
+bool cucd::Hook::return_error(QString err)
 {
     qWarning() << "Failed to install peer" << err;
     return false;

=== modified file 'src/com/ubuntu/content/service/hook.h'
--- src/com/ubuntu/content/service/hook.h	2013-09-25 03:14:53 +0000
+++ src/com/ubuntu/content/service/hook.h	2014-03-20 13:33:31 +0000
@@ -25,6 +25,14 @@
 
 #include "registry.h"
 
+namespace com
+{
+namespace ubuntu
+{
+namespace content
+{
+namespace detail
+{
 class Hook : public QObject
 {
     Q_OBJECT
@@ -41,5 +49,9 @@
     com::ubuntu::content::detail::PeerRegistry* registry;
     
 };
+}
+}
+}
+}
 
 #endif // HOOK_H

=== modified file 'src/com/ubuntu/content/service/main.cpp'
--- src/com/ubuntu/content/service/main.cpp	2013-10-01 16:55:39 +0000
+++ src/com/ubuntu/content/service/main.cpp	2014-03-20 13:33:31 +0000
@@ -36,7 +36,7 @@
     {
         /* list known peers for pictures */
         QStringList result;
-        registry->enumerate_known_peers_for_type(
+        registry->enumerate_known_sources_for_type(
             cuc::Type::Known::pictures(),
             [&result](const cuc::Peer& peer)
             {

=== modified file 'src/com/ubuntu/content/service/registry.cpp'
--- src/com/ubuntu/content/service/registry.cpp	2014-01-29 19:24:02 +0000
+++ src/com/ubuntu/content/service/registry.cpp	2014-03-20 13:33:31 +0000
@@ -17,80 +17,181 @@
  */
 
 #include "registry.h"
+#include "utils.cpp"
 #include <upstart-app-launch.h>
 
 Registry::Registry() :
-    m_defaultPeers(new QGSettings("com.ubuntu.content.hub.default",
+    m_defaultSources(new QGSettings("com.ubuntu.content.hub.default",
                                   "/com/ubuntu/content/hub/peers/")),
-    m_peers(new QGSettings("com.ubuntu.content.hub.all",
-                           "/com/ubuntu/content/hub/peers/"))
+    m_sources(new QGSettings("com.ubuntu.content.hub.source",
+                           "/com/ubuntu/content/hub/source/")),
+    m_dests(new QGSettings("com.ubuntu.content.hub.destination",
+                           "/com/ubuntu/content/hub/destination/")),
+    m_shares(new QGSettings("com.ubuntu.content.hub.share",
+                           "/com/ubuntu/content/hub/share/"))
 {
+    /* ensure all default sources are registered as available sources */
+    QList<cuc::Type> types = known_types();
+    Q_FOREACH (cuc::Type type, types)
+    {
+        if (m_defaultSources->keys().contains(type.id()))
+        {
+            QString peer_id = m_defaultSources->get(type.id()).toString();
+            QStringList as(m_defaultSources->get(type.id()).toStringList());
+            if (!as.isEmpty())
+            {
+                std::string pkg = as[0].toStdString();
+                std::string app = as[1].toStdString();
+                std::string ver = as[2].toStdString();
+                cuc::Peer peer(QString::fromLocal8Bit(upstart_app_launch_triplet_to_app_id(pkg.c_str(), app.c_str(), ver.c_str())));
+                install_source_for_type(type, cuc::Peer{peer.id(), true});
+            }
+        }
+    }
 }
 
 Registry::~Registry() {}
 
-cuc::Peer Registry::default_peer_for_type(cuc::Type type)
-{
-    qDebug() << Q_FUNC_INFO << type.id();
-    if (m_defaultPeers->keys().contains(type.id()))
-    {
-        QStringList as(m_defaultPeers->get(type.id()).toStringList());
-        std::string pkg = as[0].toStdString();
-        std::string app = as[1].toStdString();
-        std::string ver = as[2].toStdString();
-        return cuc::Peer(QString::fromLocal8Bit(upstart_app_launch_triplet_to_app_id(pkg.c_str(), app.c_str(), ver.c_str())));
-    }
-    else
-        return cuc::Peer();
-}
-
-void Registry::enumerate_known_peers_for_type(cuc::Type type, const std::function<void(const cuc::Peer&)>&for_each)
-{
-    qDebug() << Q_FUNC_INFO << type.id();
-
-    Q_FOREACH (QString k, m_peers->get(type.id()).toStringList())
-    {
-        qDebug() << Q_FUNC_INFO << k;
-        for_each(k);
-    }
+cuc::Peer Registry::default_source_for_type(cuc::Type type)
+{
+    qDebug() << Q_FUNC_INFO << type.id();
+    if (m_defaultSources->keys().contains(type.id()))
+    {
+        QStringList as(m_defaultSources->get(type.id()).toStringList());
+        if (!as.isEmpty())
+        {
+            std::string pkg = as[0].toStdString();
+            std::string app = as[1].toStdString();
+            std::string ver = as[2].toStdString();
+            return cuc::Peer(QString::fromLocal8Bit(upstart_app_launch_triplet_to_app_id(pkg.c_str(), app.c_str(), ver.c_str())), true);
+        }
+    }
+
+    return cuc::Peer();
 }
 
 void Registry::enumerate_known_peers(const std::function<void(const cuc::Peer&)>&for_each)
 {
     qDebug() << Q_FUNC_INFO;
 
-    Q_FOREACH (QString type_id, m_peers->keys())
-    {
-        qDebug() << Q_FUNC_INFO << type_id;
-        Q_FOREACH (QString k, m_peers->get(type_id).toStringList())
-        {
-            qDebug() << Q_FUNC_INFO << k;
-            for_each(k);
-        }
-    }
-}
-
-bool Registry::install_default_peer_for_type(cuc::Type type, cuc::Peer peer)
+    Q_FOREACH (QString type_id, m_sources->keys())
+    {
+        qDebug() << Q_FUNC_INFO << type_id;
+        Q_FOREACH (QString k, m_sources->get(type_id).toStringList())
+        {
+            qDebug() << Q_FUNC_INFO << k;
+            for_each(cuc::Peer{k});
+        }
+    }
+    Q_FOREACH (QString type_id, m_dests->keys())
+    {
+        qDebug() << Q_FUNC_INFO << type_id;
+        Q_FOREACH (QString k, m_dests->get(type_id).toStringList())
+        {
+            qDebug() << Q_FUNC_INFO << k;
+            for_each(cuc::Peer{k});
+        }
+    }
+    Q_FOREACH (QString type_id, m_shares->keys())
+    {
+        qDebug() << Q_FUNC_INFO << type_id;
+        Q_FOREACH (QString k, m_shares->get(type_id).toStringList())
+        {
+            qDebug() << Q_FUNC_INFO << k;
+            for_each(cuc::Peer{k});
+        }
+    }
+}
+
+void Registry::enumerate_known_sources_for_type(cuc::Type type, const std::function<void(const cuc::Peer&)>&for_each)
+{
+    qDebug() << Q_FUNC_INFO << type.id();
+
+    if (type == cuc::Type::unknown())
+        return;
+
+    Q_FOREACH (QString k, m_sources->get(type.id()).toStringList())
+    {
+        qDebug() << Q_FUNC_INFO << k;
+        bool defaultPeer = false;
+        QStringList as(m_defaultSources->get(type.id()).toStringList());
+        if (!as.isEmpty())
+        {   
+            std::string pkg = as[0].toStdString();
+            std::string app = as[1].toStdString();
+            std::string ver = as[2].toStdString();
+            defaultPeer = QString::fromLocal8Bit(upstart_app_launch_triplet_to_app_id(pkg.c_str(), app.c_str(), ver.c_str())) == k;
+        }
+        for_each(cuc::Peer{k, defaultPeer});
+    }
+}
+
+void Registry::enumerate_known_destinations_for_type(cuc::Type type, const std::function<void(const cuc::Peer&)>&for_each)
+{
+    qDebug() << Q_FUNC_INFO << type.id();
+    Q_FOREACH (QString k, m_dests->get(type.id()).toStringList())
+    {
+        qDebug() << Q_FUNC_INFO << k;
+        for_each(cuc::Peer{k});
+    }
+}
+
+void Registry::enumerate_known_shares_for_type(cuc::Type type, const std::function<void(const cuc::Peer&)>&for_each)
+{
+    qDebug() << Q_FUNC_INFO << type.id();
+
+    Q_FOREACH (QString k, m_shares->get(type.id()).toStringList())
+    {
+        qDebug() << Q_FUNC_INFO << k;
+        for_each(cuc::Peer{k});
+    }
+}
+
+bool Registry::install_default_source_for_type(cuc::Type type, cuc::Peer peer)
 {
     qDebug() << Q_FUNC_INFO << "type:" << type.id() << "peer:" << peer.id();
-    if (m_defaultPeers->keys().contains(type.id()))
+    if (m_defaultSources->keys().contains(type.id()))
     {
         qDebug() << Q_FUNC_INFO << "Default peer for" << type.id() << "already installed.";
         return false;
     }
 
-    this->install_peer_for_type(type, peer);
-    return m_defaultPeers->trySet(type.id(), QVariant(peer.id()));
-}
-
-bool Registry::install_peer_for_type(cuc::Type type, cuc::Peer peer)
-{