Merge lp:~ken-vandine/content-hub/peer_details into lp:content-hub

[Ken VanDine]

Marshall peer icons and name over dbus to allow display in the ContentPeerPicker with confined apps.

Marshall peer icons and name over dbus to allow display in the ContentPeerPicker with confined apps.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Michael Sheldon (michael-sheldon)]

ContentPeer: Is it worth keeping the iconName property given that we're unable to get the theme path and the content-hub service is populating this with image data for us (in src/com/ubuntu/content/peer.cpp)?

libcontent-hub.pc.in: ${includedir} isn't defined, also the include for QtDbus isn't necessary as this is automatically provided by the Qt5DBus requirement on the following line. However, this is already fixed in the peer_picker_ui branch, so I don't know if you just want to leave that for now?

[lp:~ken-vandine/content-hub/peer_details]

113. By Ken VanDine on 2014-03-13

merged latest more_handlers branch

[Ken VanDine (ken-vandine)]

> ContentPeer: Is it worth keeping the iconName property given that we're unable
> to get the theme path and the content-hub service is populating this with
> image data for us (in src/com/ubuntu/content/peer.cpp)?

We still need the iconName in the peer for the themed icons, the service can't render them but the client can. However the client can't find the iconName based on the app, so needs the service created Peer to provide that.

>
> libcontent-hub.pc.in: ${includedir} isn't defined, also the include for QtDbus
> isn't necessary as this is automatically provided by the Qt5DBus requirement
> on the following line. However, this is already fixed in the peer_picker_ui
> branch, so I don't know if you just want to leave that for now?

I cherry picked your fix.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Michael Sheldon (michael-sheldon)]

All looks good, as with the other merge request it just needs the submission template filled out.

[Ken VanDine (ken-vandine)]

Are there any related MPs required for this MP to build/function as expected?
 * Yes
   - https://code.launchpad.net/~ken-vandine/content-hub/more_handlers/+merge/210006
Is your branch in sync with latest trunk
 * 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?
 * No UI changes
If you changed the packaging (debian), did you subscribe a core-dev to this MP?
 * No packaging changes

[Michael Sheldon (michael-sheldon)]

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

 * Yes, based on: https://wiki.ubuntu.com/Process/Merges/TestPlan/content-hub but using Gallery from lp:~ken-vandine/gallery-app/content_hub/ (r923) and Address Book from lp:~michael-sheldon/address-book-app/new-content-hub-api (r147) for compatibility with the content-hub API changes in this MR.

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

[lp:~ken-vandine/content-hub/peer_details]

114. By Ken VanDine on 2014-03-19

merged trunk

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-12-06 12:33:14 +0000
+++ CMakeLists.txt	2014-03-19 13:45:37 +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)

=== 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-19 13:45:37 +0000
@@ -0,0 +1,207 @@
+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: "com.ubuntu.developer.ken-vandine.hub-exporter"
+    width: units.gu(50)
+    height: units.gu(60)
+
+    property bool pickMode: activeTransfer.state === ContentTransfer.InProgress
+    property var selectedItems: []
+    property var activeTransfer
+
+    function __returnResult() {
+        activeTransfer.items = selectedItems;
+        activeTransfer.state = ContentTransfer.Charged;
+    }
+
+    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 = ContentHub.exportContent(ContentType.Pictures, picDest);
+                              activeTransfer.items = [ resultComponent.createObject(root, {"url": src}) ];
+                              actPop.hide();
+                          }
+                      }
+                      Action {
+                          text: "Share"
+                          onTriggered: {
+                              print(text + ": " + src);
+                              activeTransfer = ContentHub.shareContent(ContentType.Pictures, picShare);
+                              activeTransfer.items = [ resultComponent.createObject(root, {"url": src}) ];
+                              actPop.hide();
+                          }
+                      }
+                    }
+                }
+            }
+        }
+    }
+
+    ContentPeer {
+        id: picDest
+        appId: "com.ubuntu.developer.ken-vandine.hub-importer_hub-importer_0.2"
+    }
+
+    ContentPeer {
+        id: picShare
+        appId: "com.ubuntu.developer.ken-vandine.hub-share_hub-share_0.2"
+    }
+
+    ContentImportHint {
+        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/exporter/CMakeLists.txt'
--- examples/exporter/CMakeLists.txt	2013-08-28 18:22:37 +0000
+++ examples/exporter/CMakeLists.txt	2014-03-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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/importer/CMakeLists.txt'
--- examples/importer/CMakeLists.txt	2013-08-28 18:22:37 +0000
+++ examples/importer/CMakeLists.txt	2014-03-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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();
 }

=== 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-19 13:45:37 +0000
@@ -26,7 +26,14 @@
 
 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
     contenthub.h
@@ -52,8 +59,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})

=== 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-19 13:45:37 +0000
@@ -25,6 +25,7 @@
 #include <com/ubuntu/content/peer.h>
 #include <com/ubuntu/content/type.h>
 
+#include <QStringList>
 #include <QDebug>
 
 /*!
@@ -115,6 +116,8 @@
             this, SLOT(handleImport(com::ubuntu::content::Transfer*)));
     connect(m_handler, SIGNAL(exportRequested(com::ubuntu::content::Transfer*)),
             this, SLOT(handleExport(com::ubuntu::content::Transfer*)));
+    connect(m_handler, SIGNAL(shareRequested(com::ubuntu::content::Transfer*)),
+            this, SLOT(handleShare(com::ubuntu::content::Transfer*)));
 }
 
 /*!
@@ -127,7 +130,7 @@
     qDebug() << Q_FUNC_INFO;
 
     const cuc::Type &hubType = ContentType::contentType2HubType(type);
-    cuc::Peer hubPeer = m_hub->default_peer_for_type(hubType);
+    cuc::Peer hubPeer = m_hub->default_source_for_type(hubType);
 
     ContentPeer *qmlPeer = new ContentPeer(this);
     qmlPeer->setPeer(hubPeer);
@@ -188,10 +191,10 @@
     qDebug() << Q_FUNC_INFO;
 
     const cuc::Type &hubType = ContentType::contentType2HubType(type);
-    QVector<cuc::Peer> hubPeers = m_hub->known_peers_for_type(hubType);
+    QVector<cuc::Peer> hubPeers = m_hub->known_sources_for_type(hubType);
 
     QVariantList qmlPeers;
-    foreach (const cuc::Peer &hubPeer, hubPeers) {
+    Q_FOREACH (const cuc::Peer &hubPeer, hubPeers) {
         ContentPeer *qmlPeer = new ContentPeer(this);
         qmlPeer->setPeer(hubPeer);
         qmlPeers.append(QVariant::fromValue(qmlPeer));
@@ -211,8 +214,7 @@
     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);
+    cuc::Peer hubPeer = m_hub->default_source_for_type(hubType);
 
     return importContent(hubType, hubPeer);
 }
@@ -238,16 +240,12 @@
  * \a peer
  * \internal
  */
-ContentTransfer* ContentHub::importContent(const com::ubuntu::content::Type &hubType,
+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;
-
+    cuc::Transfer *hubTransfer = m_hub->create_import_from_peer(hubPeer);
     ContentTransfer *qmlTransfer = new ContentTransfer(this);
-    qmlTransfer->setTransfer(hubTransfer, ContentTransfer::Import);
+    qmlTransfer->setTransfer(hubTransfer);
     m_activeImports.insert(hubTransfer, qmlTransfer);
     return qmlTransfer;
 }
@@ -271,6 +269,103 @@
     return QQmlListProperty<ContentTransfer>(this, m_finishedImports);
 }
 
+/* EXPORTS */
+/*!
+ * \qmlmethod ContentHub::exportContent(ContentType)
+ * \overload ContentHub::exportContent(ContentType, ContentPeer)
+ *
+ * \brief Request to export data of \a ContentType to the default
+ * ContentPeer
+ */
+ContentTransfer *ContentHub::exportContent(int type)
+{
+    qDebug() << Q_FUNC_INFO << static_cast<ContentType::Type>(type);
+
+    const cuc::Type &hubType = ContentType::contentType2HubType(type);
+    cuc::Peer hubPeer = m_hub->default_source_for_type(hubType);
+    return exportContent(hubType, hubPeer);
+}
+
+/*!
+ * \qmlmethod ContentHub::exportContent(ContentType, ContentPeer)
+ * \overload ContentHub::exportContent(ContentType)
+ *
+ * \brief Request to export data of \a ContentType to the
+ * specified \a ContentPeer
+ */
+ContentTransfer *ContentHub::exportContent(int type, ContentPeer *peer)
+{
+    qDebug() << Q_FUNC_INFO << static_cast<ContentType::Type>(type) << peer;
+
+    const cuc::Type &hubType = ContentType::contentType2HubType(type);
+    return exportContent(hubType, peer->peer());
+}
+
+/*!
+ * \brief ContentHub::exportContent creates a ContentTransfer object
+ * \a type
+ * \a peer
+ * \internal
+ */
+ContentTransfer* ContentHub::exportContent(const com::ubuntu::content::Type& /*hubType*/,
+                                           const com::ubuntu::content::Peer &hubPeer)
+{
+    cuc::Transfer *hubTransfer = m_hub->create_export_to_peer(hubPeer);
+    ContentTransfer *qmlTransfer = new ContentTransfer(this);
+    qmlTransfer->setTransfer(hubTransfer);
+    m_activeImports.insert(hubTransfer, qmlTransfer);
+    return qmlTransfer;
+}
+
+/* SHARE */
+/*!
+ * \qmlmethod ContentHub::shareContent(ContentType)
+ * \overload ContentHub::shareContent(ContentType, ContentPeer)
+ *
+ * \brief Request to share data of \a ContentType to the default
+ * ContentPeer
+ */
+ContentTransfer *ContentHub::shareContent(int type)
+{
+    qDebug() << Q_FUNC_INFO << static_cast<ContentType::Type>(type);
+
+    const cuc::Type &hubType = ContentType::contentType2HubType(type);
+    // FIXME: This is the wrong way to get the default peer for shares
+    cuc::Peer hubPeer = m_hub->default_source_for_type(hubType);
+    return shareContent(hubType, hubPeer);
+}
+
+/*!
+ * \qmlmethod ContentHub::shareContent(ContentType, ContentPeer)
+ * \overload ContentHub::shareContent(ContentType)
+ *
+ * \brief Request to share data of \a ContentType to the
+ * specified \a ContentPeer
+ */
+ContentTransfer *ContentHub::shareContent(int type, ContentPeer *peer)
+{
+    qDebug() << Q_FUNC_INFO << static_cast<ContentType::Type>(type) << peer;
+
+    const cuc::Type &hubType = ContentType::contentType2HubType(type);
+    return shareContent(hubType, peer->peer());
+}
+
+/*!
+ * \brief ContentHub::shareContent creates a ContentTransfer object
+ * \a type
+ * \a peer
+ * \internal
+ */
+ContentTransfer* ContentHub::shareContent(const com::ubuntu::content::Type& /*hubType*/,
+                                           const com::ubuntu::content::Peer &hubPeer)
+{
+    cuc::Transfer *hubTransfer = m_hub->create_share_to_peer(hubPeer);
+    ContentTransfer *qmlTransfer = new ContentTransfer(this);
+    qmlTransfer->setTransfer(hubTransfer);
+    m_activeImports.insert(hubTransfer, qmlTransfer);
+    return qmlTransfer;
+}
+
 /*!
  * \brief ContentHub::handleImport handles an incoming request for importing content
  * \internal
@@ -283,8 +378,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 +399,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 +461,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-19 13:45:37 +0000
@@ -55,25 +55,40 @@
     Q_INVOKABLE ContentTransfer* importContent(int type);
     Q_INVOKABLE ContentTransfer* importContent(int type, ContentPeer *peer);
 
+    Q_INVOKABLE ContentTransfer* exportContent(int type);
+    Q_INVOKABLE ContentTransfer* exportContent(int type, ContentPeer *peer);
+
+    Q_INVOKABLE ContentTransfer* shareContent(int type);
+    Q_INVOKABLE ContentTransfer* shareContent(int type, ContentPeer *peer);
+
     Q_INVOKABLE void restoreImports();
 
     QQmlListProperty<ContentTransfer> finishedImports();
 
 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 handleShare(com::ubuntu::content::Transfer * transfer);
+    void updateState();
 
 private:
-    ContentTransfer* importContent(const com::ubuntu::content::Type &hubType,
+    ContentTransfer* importContent(const com::ubuntu::content::Type&,
+                                   const com::ubuntu::content::Peer &hubPeer);
+
+    ContentTransfer* exportContent(const com::ubuntu::content::Type&,
+                                   const com::ubuntu::content::Peer &hubPeer);
+    ContentTransfer* shareContent(const com::ubuntu::content::Type&,
                                    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;
 };

=== 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-19 13:45:37 +0000
@@ -15,10 +15,9 @@
  */
 
 #include "contentpeer.h"
-
 #include <com/ubuntu/content/peer.h>
-
 #include <QDebug>
+#include <QIcon>
 
 /*!
  * \qmltype ContentPeer
@@ -64,6 +63,23 @@
 }
 
 /*!
+ * \brief ContentPeer::setAppId
+ *
+ * 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
  */
@@ -78,7 +94,15 @@
  */
 void ContentPeer::setPeer(const cuc::Peer &peer)
 {
+    qDebug() << Q_FUNC_INFO;
     m_peer = peer;
+    if (peer.icon().isNull())
+    {
+        if (QIcon::hasThemeIcon(peer.iconName().toUtf8()))
+            m_icon = QIcon::fromTheme(peer.iconName().toUtf8()).pixmap(256).toImage();
+    } else
+        m_icon = peer.icon();
+
     Q_EMIT nameChanged();
     Q_EMIT appIdChanged();
 }

=== 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-19 13:45:37 +0000
@@ -21,18 +21,21 @@
 
 #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(QImage icon READ icon)
 
 public:
     ContentPeer(QObject *parent = nullptr);
 
     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);
@@ -43,6 +46,7 @@
 
 private:
     com::ubuntu::content::Peer m_peer;
+    QImage m_icon;
 };
 
 #endif // COM_UBUNTU_CONTENTPEER_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-19 13:45:37 +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 {
@@ -230,7 +239,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 +251,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 +271,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,11 +292,16 @@
  */
 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());
+    qDebug() << Q_FUNC_INFO << "m_state";
     Q_EMIT stateChanged();
 }
 
@@ -303,7 +313,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 +331,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-19 13:45:37 +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/qmlimportexporthandler.cpp'
--- import/Ubuntu/Content/qmlimportexporthandler.cpp	2013-08-23 15:51:35 +0000
+++ import/Ubuntu/Content/qmlimportexporthandler.cpp	2014-03-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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,12 +32,13 @@
 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(QImage icon READ icon WRITE setIcon)
+    Q_PROPERTY(QString iconName READ iconName WRITE setIconName)
 
   public:
     static const Peer& unknown();
-
     Peer(const QString& id = QString(), QObject* parent = nullptr);
     Peer(const Peer& rhs);
     virtual ~Peer();
@@ -44,7 +47,12 @@
     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 QImage icon() const;
+    Q_INVOKABLE void setIcon(const QImage&);
+    Q_INVOKABLE virtual QString iconName() const;
+    Q_INVOKABLE void setIconName(const QString&);
 
   private:
     struct Private;
@@ -54,4 +62,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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +0000
@@ -16,14 +16,44 @@
  * 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) : id(id)
+    {
+        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))
+                        icon = QImage(iconName);
+                    g_object_unref(ic);
+                }
+
+                g_object_unref(app);
+            }
+        }
+    }
+
     QString id;
+    QString name;
+    QImage icon;
+    QString iconName;
 };
 
 const cuc::Peer& cuc::Peer::unknown()
@@ -34,6 +64,7 @@
 
 cuc::Peer::Peer(const QString& id, QObject* parent) : QObject(parent), d(new cuc::Peer::Private{id})
 {
+    qDebug() << Q_FUNC_INFO;
 }
 
 cuc::Peer::Peer(const cuc::Peer& rhs) : QObject(rhs.parent()), d(rhs.d)
@@ -63,11 +94,75 @@
     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;
+}
+
+QImage cuc::Peer::icon() const
+{
+    return d->icon;
+}
+
+void cuc::Peer::setIcon(const QImage& icon)
+{
+    if (icon != d->icon)
+        d->icon = icon;
+}
+
+QString cuc::Peer::iconName() const
+{
+    return d->iconName;
+}
+
+void cuc::Peer::setIconName(const QString& iconName)
+{
+    if (iconName != d->iconName)
+        d->iconName = iconName;
+}
+
+QDBusArgument &operator<<(QDBusArgument &argument, const cuc::Peer& peer)
+{
+    QImage i = peer.icon();
+    QByteArray ba;
+    QBuffer buffer(&ba);
+    buffer.open(QIODevice::WriteOnly);
+    i.save(&buffer,"PNG");
+
+    argument.beginStructure();
+    argument << peer.id() << peer.name() << ba << peer.iconName();
+    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;
+
+    argument.beginStructure();
+    argument >> id >> name >> ic >> iconName;
+    argument.endStructure();
+
+    QImage icon;
+    bool ret = icon.loadFromData(reinterpret_cast<const uchar*>(ic.constData()), ic.size(), "png");
+    if (ret)
+        qDebug() << Q_FUNC_INFO << "SUCCESS";
+    else
+        qDebug() << Q_FUNC_INFO << "FAIL";
+
+    peer = cuc::Peer{id};
+    peer.setName(name);
+    peer.setIcon(icon);
+    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-19 13:45:37 +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-19 13:45:37 +0000
@@ -14,7 +14,35 @@
       <default>[]</default>
     </key>
   </schema>
-  <schema id="com.ubuntu.content.hub.all" path="/com/ubuntu/content/hub/peers/">
+  <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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +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-19 13:45:37 +0000
@@ -17,80 +17,172 @@
  */
 
 #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()});
+            }
+        }
+    }
 }
 
 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())));
+        }
+    }
+
+    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;
+        for_each(cuc::Peer{k});
+    }
+}
+
+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)
-{
-    qDebug() << Q_FUNC_INFO << "type:" << type.id() << "peer:" << peer.id();
-    QStringList l = m_peers->get(type.id()).toStringList();
-    if (not l.contains(peer.id()))
-    {
-        l.append(peer.id());
-        return m_peers->trySet(type.id(), QVariant(l));
+    this->install_source_for_type(type, peer);
+    return m_defaultSources->trySet(type.id(), QVariant(peer.id()));
+}
+
+bool Registry::install_source_for_type(cuc::Type type, cuc::Peer peer)
+{
+    qDebug() << Q_FUNC_INFO << "type:" << type.id() << "peer:" << peer.id();
+    QStringList l = m_sources->get(type.id()).toStringList();
+    if (not l.contains(peer.id()))
+    {
+        l.append(peer.id());
+        return m_sources->trySet(type.id(), QVariant(l));
+    }
+    return false;
+}
+
+bool Registry::install_destination_for_type(cuc::Type type, cuc::Peer peer)
+{
+    qDebug() << Q_FUNC_INFO << "type:" << type.id() << "peer:" << peer.id();
+    QStringList l = m_dests->get(type.id()).toStringList();
+    if (not l.contains(peer.id()))
+    {
+        l.append(peer.id());
+        return m_dests->trySet(type.id(), QVariant(l));
+    }
+    return false;
+}
+
+bool Registry::install_share_for_type(cuc::Type type, cuc::Peer peer)
+{
+    qDebug() << Q_FUNC_INFO << "type:" << type.id() << "peer:" << peer.id();
+    QStringList l = m_shares->get(type.id()).toStringList();
+    if (not l.contains(peer.id()))
+    {
+        l.append(peer.id());
+        return m_shares->trySet(type.id(), QVariant(l));
     }
     return false;
 }
@@ -99,13 +191,31 @@
 {
     qDebug() << Q_FUNC_INFO << "peer:" << peer.id();
     bool ret = false;
-    Q_FOREACH (QString type_id, m_peers->keys())
-    {
-        QStringList l = m_peers->get(type_id).toStringList();
-        if (l.contains(peer.id()))
-        {
-            l.removeAll(peer.id());
-            ret = m_peers->trySet(type_id, QVariant(l));
+    Q_FOREACH (QString type_id, m_sources->keys())
+    {
+        QStringList l = m_sources->get(type_id).toStringList();
+        if (l.contains(peer.id()))
+        {
+            l.removeAll(peer.id());
+            ret = m_sources->trySet(type_id, QVariant(l));
+        }
+    }
+    Q_FOREACH (QString type_id, m_dests->keys())
+    {
+        QStringList l = m_dests->get(type_id).toStringList();
+        if (l.contains(peer.id()))
+        {
+            l.removeAll(peer.id());
+            ret = m_dests->trySet(type_id, QVariant(l));
+        }
+    }
+    Q_FOREACH (QString type_id, m_shares->keys())
+    {
+        QStringList l = m_shares->get(type_id).toStringList();
+        if (l.contains(peer.id()))
+        {
+            l.removeAll(peer.id());
+            ret = m_shares->trySet(type_id, QVariant(l));
         }
     }
     return ret;

=== modified file 'src/com/ubuntu/content/service/registry.h'
--- src/com/ubuntu/content/service/registry.h	2013-09-20 19:54:51 +0000
+++ src/com/ubuntu/content/service/registry.h	2014-03-19 13:45:37 +0000
@@ -34,16 +34,22 @@
 public:
     Registry();
     ~Registry();
-    cuc::Peer default_peer_for_type(cuc::Type type);
-    void enumerate_known_peers_for_type(cuc::Type type, const std::function<void(const cuc::Peer&)>& for_each);
+    cuc::Peer default_source_for_type(cuc::Type type);
     void enumerate_known_peers(const std::function<void(const cuc::Peer&)>& for_each);
-    bool install_default_peer_for_type(cuc::Type type, cuc::Peer peer);
-    bool install_peer_for_type(cuc::Type type, cuc::Peer peer);    
+    void enumerate_known_sources_for_type(cuc::Type type, const std::function<void(const cuc::Peer&)>& for_each);   
+    void enumerate_known_destinations_for_type(cuc::Type type, const std::function<void(const cuc::Peer&)>& for_each);
+    void enumerate_known_shares_for_type(cuc::Type type, const std::function<void(const cuc::Peer&)>& for_each);
+    bool install_default_source_for_type(cuc::Type type, cuc::Peer peer);
+    bool install_source_for_type(cuc::Type type, cuc::Peer peer);    
+    bool install_destination_for_type(cuc::Type type, cuc::Peer peer);
+    bool install_share_for_type(cuc::Type type, cuc::Peer peer);
     bool remove_peer(cuc::Peer peer);
 
 private:
-    QScopedPointer<QGSettings> m_defaultPeers;
-    QScopedPointer<QGSettings> m_peers;
+    QScopedPointer<QGSettings> m_defaultSources;
+    QScopedPointer<QGSettings> m_sources;
+    QScopedPointer<QGSettings> m_dests;
+    QScopedPointer<QGSettings> m_shares;
 };
 
 #endif // REGISTRY_H

=== modified file 'src/com/ubuntu/content/transfer.cpp'
--- src/com/ubuntu/content/transfer.cpp	2013-10-01 16:55:39 +0000
+++ src/com/ubuntu/content/transfer.cpp	2014-03-19 13:45:37 +0000
@@ -101,3 +101,8 @@
 {
     return d->setSelectionType(type);
 }
+
+cuc::Transfer::Direction cuc::Transfer::direction() const
+{
+    return d->direction();
+}

=== modified file 'src/com/ubuntu/content/transfer_p.h'
--- src/com/ubuntu/content/transfer_p.h	2013-10-01 16:55:39 +0000
+++ src/com/ubuntu/content/transfer_p.h	2014-03-19 13:45:37 +0000
@@ -178,6 +178,18 @@
         return not reply.isError();
     }
 
+    Direction direction()
+    {
+        auto reply = remote_transfer->Direction();
+        reply.waitForFinished();
+
+        /* if Direction fails, default to import */
+        if (reply.isError())
+            return Transfer::Direction::Import;
+
+        return static_cast<Transfer::Direction>(reply.value());
+    }
+
     com::ubuntu::content::dbus::Transfer* remote_transfer;
 };
 }

=== modified file 'src/com/ubuntu/content/utils.cpp'
--- src/com/ubuntu/content/utils.cpp	2013-10-01 16:55:39 +0000
+++ src/com/ubuntu/content/utils.cpp	2014-03-19 13:45:37 +0000
@@ -27,9 +27,22 @@
 #include <nih-dbus/dbus_util.h>
 
 #include "common.h"
+#include "com/ubuntu/content/type.h"
+
+namespace cuc = com::ubuntu::content;
 
 namespace {
 
+QList<cuc::Type> known_types()
+{
+    QList<cuc::Type> types;
+    types << cuc::Type::Known::pictures();
+    types << cuc::Type::Known::music();
+    types << cuc::Type::Known::documents();
+    types << cuc::Type::Known::contacts();
+    return types;
+}
+
 /* sanitize the dbus names */
 QString sanitize_id(const QString& appId)
 {

=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2013-10-09 22:39:03 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2014-03-19 13:45:37 +0000
@@ -17,14 +17,14 @@
 qt5_wrap_cpp(MOCS test_harness.h)
 
 add_executable(
-  app_hub_communication_default_peer
-  app_hub_communication_default_peer.cpp
+  app_hub_communication_default_source
+  app_hub_communication_default_source.cpp
   ${MOCS}
 )
 
 add_executable(
-  app_hub_communication_known_peers
-  app_hub_communication_known_peers.cpp
+  app_hub_communication_known_sources
+  app_hub_communication_known_sources.cpp
   ${MOCS}
 )
 
@@ -62,25 +62,25 @@
   bad.json
 )
 
-qt5_use_modules(app_hub_communication_default_peer Core Test)
-qt5_use_modules(app_hub_communication_known_peers Core Test)
-qt5_use_modules(app_hub_communication_stores Core Test)
-qt5_use_modules(app_hub_communication_transfer Core Test)
-qt5_use_modules(app_hub_communication_handler Core Test)
+qt5_use_modules(app_hub_communication_default_source Core Gui DBus Test)
+qt5_use_modules(app_hub_communication_known_sources Core Gui DBus Test)
+qt5_use_modules(app_hub_communication_stores Core Gui DBus Test)
+qt5_use_modules(app_hub_communication_transfer Core Gui DBus Test)
+qt5_use_modules(app_hub_communication_handler Core Gui DBus Test)
 qt5_use_modules(test_utils Core Test)
-qt5_use_modules(test_hook Core Test)
+qt5_use_modules(test_hook Core Gui DBus Test)
 
 target_link_libraries(app_hub_communication_stores content-hub gmock gtest gtest_main)
-target_link_libraries(app_hub_communication_default_peer content-hub gmock gtest gtest_main)
-target_link_libraries(app_hub_communication_known_peers content-hub gmock gtest gtest_main)
+target_link_libraries(app_hub_communication_default_source content-hub gmock gtest gtest_main)
+target_link_libraries(app_hub_communication_known_sources content-hub gmock gtest gtest_main)
 target_link_libraries(app_hub_communication_stores content-hub gmock gtest gtest_main)
 target_link_libraries(app_hub_communication_transfer content-hub gmock gtest gtest_main)
 target_link_libraries(app_hub_communication_handler content-hub gmock gtest gtest_main)
 target_link_libraries(test_utils content-hub gmock gtest gtest_main)
 target_link_libraries(test_hook content-hub gmock gtest gtest_main ${GSETTINGS_LDFLAGS})
 
-add_test(app_hub_communication_default_peer app_hub_communication_default_peer)
-add_test(app_hub_communication_known_peers app_hub_communication_known_peers)
+add_test(app_hub_communication_default_source app_hub_communication_default_source)
+add_test(app_hub_communication_known_sources app_hub_communication_known_sources)
 add_test(app_hub_communication_stores app_hub_communication_stores)
 add_test(app_hub_communication_transfer app_hub_communication_transfer)
 add_test(app_hub_communication_handler app_hub_communication_handler)

=== renamed file 'tests/acceptance-tests/app_hub_communication_default_peer.cpp' => 'tests/acceptance-tests/app_hub_communication_default_source.cpp'
--- tests/acceptance-tests/app_hub_communication_default_peer.cpp	2013-09-25 03:14:53 +0000
+++ tests/acceptance-tests/app_hub_communication_default_source.cpp	2014-03-19 13:45:37 +0000
@@ -60,16 +60,20 @@
     {
         using namespace ::testing;
 
-        ON_CALL(*this, default_peer_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
-        ON_CALL(*this, install_default_peer_for_type(_,_)).WillByDefault(Return(false));
-        ON_CALL(*this, install_peer_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, default_source_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
+        ON_CALL(*this, install_default_source_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, install_source_for_type(_,_)).WillByDefault(Return(false));
     }
 
-    MOCK_METHOD1(default_peer_for_type, cuc::Peer(cuc::Type t));
-    MOCK_METHOD2(enumerate_known_peers_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD1(default_source_for_type, cuc::Peer(cuc::Type t));
     MOCK_METHOD1(enumerate_known_peers, void(const std::function<void(const cuc::Peer&)>&));
-    MOCK_METHOD2(install_default_peer_for_type, bool(cuc::Type, cuc::Peer));
-    MOCK_METHOD2(install_peer_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(enumerate_known_sources_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_destinations_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_shares_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(install_default_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_destination_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_share_for_type, bool(cuc::Type, cuc::Peer));
     MOCK_METHOD1(remove_peer, bool(cuc::Peer));
 };
 }
@@ -90,7 +94,7 @@
         QDBusConnection connection = QDBusConnection::sessionBus();        
         
         auto mock = new MockedPeerRegistry{};
-        EXPECT_CALL(*mock, default_peer_for_type(_)).
+        EXPECT_CALL(*mock, default_source_for_type(_)).
         Times(Exactly(1)).
         WillRepeatedly(Return(cuc::Peer{default_peer_id}));
 
@@ -124,7 +128,7 @@
         test::TestHarness harness;
         harness.add_test_case([hub, default_peer_id]()
         {            
-            EXPECT_EQ(default_peer_id, hub->default_peer_for_type(cuc::Type::Known::documents()).id());
+            EXPECT_EQ(default_peer_id, hub->default_source_for_type(cuc::Type::Known::documents()).id());
         });
         
         EXPECT_EQ(0, QTest::qExec(std::addressof(harness)));

=== modified file 'tests/acceptance-tests/app_hub_communication_handler.cpp'
--- tests/acceptance-tests/app_hub_communication_handler.cpp	2013-09-25 03:14:53 +0000
+++ tests/acceptance-tests/app_hub_communication_handler.cpp	2014-03-19 13:45:37 +0000
@@ -63,11 +63,15 @@
         using namespace ::testing;
     }
 
-    MOCK_METHOD1(default_peer_for_type, cuc::Peer(cuc::Type t));
-    MOCK_METHOD2(enumerate_known_peers_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD1(default_source_for_type, cuc::Peer(cuc::Type t));
     MOCK_METHOD1(enumerate_known_peers, void(const std::function<void(const cuc::Peer&)>&));
-    MOCK_METHOD2(install_default_peer_for_type, bool(cuc::Type, cuc::Peer));
-    MOCK_METHOD2(install_peer_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(enumerate_known_sources_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_destinations_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_shares_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(install_default_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_destination_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_share_for_type, bool(cuc::Type, cuc::Peer));
     MOCK_METHOD1(remove_peer, bool(cuc::Peer));
 };
 
@@ -76,13 +80,14 @@
     MockedHandler() : cuc::ImportExportHandler()
     {
         using namespace ::testing;
+        ON_CALL(*this, handle_import(_)).WillByDefault(Return());
         ON_CALL(*this, handle_export(_)).WillByDefault(Return());
-        ON_CALL(*this, handle_import(_)).WillByDefault(Return());
-
+        ON_CALL(*this, handle_share(_)).WillByDefault(Return());
     }
 
+    MOCK_METHOD1(handle_import, void(cuc::Transfer*));
     MOCK_METHOD1(handle_export, void(cuc::Transfer*));
-    MOCK_METHOD1(handle_import, void(cuc::Transfer*));
+    MOCK_METHOD1(handle_share, void(cuc::Transfer*));
 };
 }
 
@@ -139,9 +144,7 @@
 
             qputenv("APP_ID", default_dest_peer_id.toLatin1());
             hub = cuc::Hub::Client::instance();
-            auto transfer = hub->create_import_for_type_from_peer(
-                cuc::Type::Known::pictures(),
-                cuc::Peer(default_peer_id));
+            auto transfer = hub->create_import_from_peer(cuc::Peer(default_peer_id));
             ASSERT_TRUE(transfer != nullptr);
             EXPECT_TRUE(transfer->start());
             EXPECT_EQ(cuc::Transfer::in_progress, transfer->state());

=== renamed file 'tests/acceptance-tests/app_hub_communication_known_peers.cpp' => 'tests/acceptance-tests/app_hub_communication_known_sources.cpp'
--- tests/acceptance-tests/app_hub_communication_known_peers.cpp	2013-09-25 03:14:53 +0000
+++ tests/acceptance-tests/app_hub_communication_known_sources.cpp	2014-03-19 13:45:37 +0000
@@ -59,16 +59,20 @@
     {
         using namespace ::testing;
 
-        ON_CALL(*this, default_peer_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
-        ON_CALL(*this, install_default_peer_for_type(_,_)).WillByDefault(Return(false));
-        ON_CALL(*this, install_peer_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, default_source_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
+        ON_CALL(*this, install_default_source_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, install_source_for_type(_,_)).WillByDefault(Return(false));
     }
 
-    MOCK_METHOD1(default_peer_for_type, cuc::Peer(cuc::Type t));
-    MOCK_METHOD2(enumerate_known_peers_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD1(default_source_for_type, cuc::Peer(cuc::Type t));
     MOCK_METHOD1(enumerate_known_peers, void(const std::function<void(const cuc::Peer&)>&));
-    MOCK_METHOD2(install_default_peer_for_type, bool(cuc::Type, cuc::Peer));
-    MOCK_METHOD2(install_peer_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(enumerate_known_sources_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_destinations_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_shares_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(install_default_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_destination_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_share_for_type, bool(cuc::Type, cuc::Peer));
     MOCK_METHOD1(remove_peer, bool(cuc::Peer));
 };
 }
@@ -100,15 +104,15 @@
         };
         
         auto mock = new MockedPeerRegistry{};
-        EXPECT_CALL(*mock, enumerate_known_peers_for_type(_, _)).
+        EXPECT_CALL(*mock, enumerate_known_sources_for_type(_, _)).
         Times(Exactly(1)).
         WillRepeatedly(Invoke(enumerate));
 
-        EXPECT_CALL(*mock, install_peer_for_type(_, _)).
+        EXPECT_CALL(*mock, install_source_for_type(_, _)).
         Times(Exactly(1)).
         WillRepeatedly(Return(true));
 
-        ASSERT_TRUE(mock->install_peer_for_type(cuc::Type::Known::documents(),
+        ASSERT_TRUE(mock->install_source_for_type(cuc::Type::Known::documents(),
                                                 cuc::Peer("com.does.not.exist.anywhere.application4")));
 
         QSharedPointer<cucd::PeerRegistry> registry{mock};
@@ -141,7 +145,7 @@
         test::TestHarness harness;
         harness.add_test_case([hub, default_peers]()
         {            
-            auto peers = hub->known_peers_for_type(cuc::Type::Known::documents());
+            auto peers = hub->known_sources_for_type(cuc::Type::Known::documents());
             ASSERT_EQ(default_peers, peers);
         });
         

=== modified file 'tests/acceptance-tests/app_hub_communication_stores.cpp'
--- tests/acceptance-tests/app_hub_communication_stores.cpp	2013-09-25 03:14:53 +0000
+++ tests/acceptance-tests/app_hub_communication_stores.cpp	2014-03-19 13:45:37 +0000
@@ -59,16 +59,20 @@
     {
         using namespace ::testing;
 
-        ON_CALL(*this, default_peer_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
-        ON_CALL(*this, install_default_peer_for_type(_,_)).WillByDefault(Return(false));
-        ON_CALL(*this, install_peer_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, default_source_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
+        ON_CALL(*this, install_default_source_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, install_source_for_type(_,_)).WillByDefault(Return(false));
     }
 
-    MOCK_METHOD1(default_peer_for_type, cuc::Peer(cuc::Type t));
-    MOCK_METHOD2(enumerate_known_peers_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD1(default_source_for_type, cuc::Peer(cuc::Type t));
     MOCK_METHOD1(enumerate_known_peers, void(const std::function<void(const cuc::Peer&)>&));
-    MOCK_METHOD2(install_default_peer_for_type, bool(cuc::Type, cuc::Peer));
-    MOCK_METHOD2(install_peer_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(enumerate_known_sources_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_destinations_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_shares_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(install_default_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_destination_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_share_for_type, bool(cuc::Type, cuc::Peer));
     MOCK_METHOD1(remove_peer, bool(cuc::Peer));
 };
 }

=== modified file 'tests/acceptance-tests/app_hub_communication_transfer.cpp'
--- tests/acceptance-tests/app_hub_communication_transfer.cpp	2013-10-09 22:39:03 +0000
+++ tests/acceptance-tests/app_hub_communication_transfer.cpp	2014-03-19 13:45:37 +0000
@@ -61,16 +61,20 @@
     {
         using namespace ::testing;
 
-        ON_CALL(*this, default_peer_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
-        ON_CALL(*this, install_default_peer_for_type(_,_)).WillByDefault(Return(false));
-        ON_CALL(*this, install_peer_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, default_source_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
+        ON_CALL(*this, install_default_source_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, install_source_for_type(_,_)).WillByDefault(Return(false));
     }
 
-    MOCK_METHOD1(default_peer_for_type, cuc::Peer(cuc::Type t));
-    MOCK_METHOD2(enumerate_known_peers_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD1(default_source_for_type, cuc::Peer(cuc::Type t));
     MOCK_METHOD1(enumerate_known_peers, void(const std::function<void(const cuc::Peer&)>&));
-    MOCK_METHOD2(install_default_peer_for_type, bool(cuc::Type, cuc::Peer));
-    MOCK_METHOD2(install_peer_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(enumerate_known_sources_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_destinations_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_shares_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(install_default_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_destination_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_share_for_type, bool(cuc::Type, cuc::Peer));
     MOCK_METHOD1(remove_peer, bool(cuc::Peer));
 };
 }
@@ -91,8 +95,8 @@
         QDBusConnection connection = QDBusConnection::sessionBus();        
         
         auto mock = new ::testing::NiceMock<MockedPeerRegistry>{};
-        EXPECT_CALL(*mock, default_peer_for_type(_)).
-        Times(Exactly(1)).
+        EXPECT_CALL(*mock, default_source_for_type(_)).
+        Times(AtLeast(1)).
         WillRepeatedly(Return(cuc::Peer{default_peer_id}));
         
         QSharedPointer<cucd::PeerRegistry> registry{mock};
@@ -134,9 +138,8 @@
 
             /** [Importing pictures] */
             auto hub = cuc::Hub::Client::instance();
-            auto transfer = hub->create_import_for_type_from_peer(
-                cuc::Type::Known::pictures(),
-                hub->default_peer_for_type(cuc::Type::Known::pictures()));
+            auto transfer = hub->create_import_from_peer(
+                hub->default_source_for_type(cuc::Type::Known::pictures()));
             ASSERT_TRUE(transfer != nullptr);
             EXPECT_EQ(cuc::Transfer::created, transfer->state());
             EXPECT_TRUE(transfer->setSelectionType(cuc::Transfer::SelectionType::multiple));
@@ -150,6 +153,25 @@
             EXPECT_EQ(cuc::Transfer::charged, transfer->state());
             EXPECT_EQ(expected_items, transfer->collect());
             /** [Importing pictures] */
+
+
+            /* Test that only a single transfer exists for the same peer */
+            auto single_transfer = hub->create_import_from_peer(
+                hub->default_source_for_type(cuc::Type::Known::pictures()));
+            ASSERT_TRUE(single_transfer != nullptr);
+            EXPECT_EQ(cuc::Transfer::created, single_transfer->state());
+            EXPECT_TRUE(single_transfer->start());
+            EXPECT_EQ(cuc::Transfer::initiated, single_transfer->state());
+
+            auto second_transfer = hub->create_import_from_peer(
+                hub->default_source_for_type(cuc::Type::Known::pictures()));
+            ASSERT_TRUE(second_transfer != nullptr);
+            EXPECT_EQ(cuc::Transfer::created, second_transfer->state());
+            /* Now that a second transfer was created, the previous
+             * transfer should have been aborted */
+            EXPECT_EQ(cuc::Transfer::aborted, single_transfer->state());
+            /* end single transfer test */
+
             hub->quit();
         });
         EXPECT_EQ(0, QTest::qExec(std::addressof(harness)));

=== modified file 'tests/acceptance-tests/app_manager_mock.h'
--- tests/acceptance-tests/app_manager_mock.h	2013-09-06 10:17:01 +0000
+++ tests/acceptance-tests/app_manager_mock.h	2014-03-19 13:45:37 +0000
@@ -31,7 +31,7 @@
 
         ON_CALL(*this, invoke_application(_)).WillByDefault(Return(true));
         ON_CALL(*this, stop_application(_)).WillByDefault(Return(true));
-        ON_CALL(*this, is_application_started(_)).WillByDefault(Return(false));
+        ON_CALL(*this, is_application_started(_)).WillByDefault(Return(true));
     }
 
     MOCK_METHOD1(invoke_application, bool(const std::string &));

=== modified file 'tests/acceptance-tests/test_hook.cpp'
--- tests/acceptance-tests/test_hook.cpp	2013-09-25 03:14:53 +0000
+++ tests/acceptance-tests/test_hook.cpp	2014-03-19 13:45:37 +0000
@@ -40,18 +40,21 @@
     {
         using namespace ::testing;
 
-        ON_CALL(*this, default_peer_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
-        ON_CALL(*this, install_default_peer_for_type(_,_)).WillByDefault(Return(false));
-        ON_CALL(*this, install_peer_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, default_source_for_type(_)).WillByDefault(Return(cuc::Peer::unknown()));
+        ON_CALL(*this, install_default_source_for_type(_,_)).WillByDefault(Return(false));
+        ON_CALL(*this, install_source_for_type(_,_)).WillByDefault(Return(false));
         ON_CALL(*this, remove_peer(_)).WillByDefault(Return(false));
     }
 
-    MOCK_METHOD1(default_peer_for_type, cuc::Peer(cuc::Type t));
-    MOCK_METHOD2(enumerate_known_peers_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
-    
-    MOCK_METHOD2(install_default_peer_for_type, bool(cuc::Type, cuc::Peer));
-    MOCK_METHOD2(install_peer_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD1(default_source_for_type, cuc::Peer(cuc::Type t));
     MOCK_METHOD1(enumerate_known_peers, void(const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_sources_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_destinations_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(enumerate_known_shares_for_type, void(cuc::Type, const std::function<void(const cuc::Peer&)>&));
+    MOCK_METHOD2(install_default_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_source_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_destination_for_type, bool(cuc::Type, cuc::Peer));
+    MOCK_METHOD2(install_share_for_type, bool(cuc::Type, cuc::Peer));
     MOCK_METHOD1(remove_peer, bool(cuc::Peer));
 };
 }
@@ -61,12 +64,12 @@
     using namespace ::testing;
     
     auto mock = new MockedRegistry{};
-    EXPECT_CALL(*mock, install_peer_for_type(_,_)).
+    EXPECT_CALL(*mock, install_source_for_type(_,_)).
     Times(Exactly(2)).
     WillRepeatedly(Return(true));
 
     QFileInfo f("good.json");
-    Hook *hook = new Hook(mock);
+    cucd::Hook *hook = new cucd::Hook(mock);
 
     EXPECT_TRUE(hook->add_peer(f));
     f.setFile("bad.json");