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

[Ken VanDine]

Pasteboard implementation

Pasteboard implementation

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

283. By Ken VanDine on 2016-06-02

fixed header

284. By Ken VanDine on 2016-06-02

Removed unused code

285. By Ken VanDine on 2016-06-07

Use UAL to ensure the app_id is correct

286. By Ken VanDine on 2016-06-07

UAL build fixes

287. By Ken VanDine on 2016-07-08

Don't block on returning paste if it doesn't exist

288. By Ken VanDine on 2016-07-08

Don't warn on empty pasteboard

289. By Ken VanDine on 2016-07-18

Use QMimeData for the Paste payload

290. By Ken VanDine on 2016-07-18

removed commented out line

291. By Ken VanDine on 2016-07-21

refactored a bit to include the mimeData when calling CreatePaste, cuts down a dbus round trip

292. By Ken VanDine on 2016-07-21

Verify app_id_matches for CreatePaste as well

293. By Ken VanDine on 2016-07-21

removed unused uuid

294. By Ken VanDine on 2016-07-21

Added Hub::pasteFormats property which contains a list of mimetypes available to paste from the pasteboard

295. By Ken VanDine on 2016-07-21

merged trunk

296. By Ken VanDine on 2016-07-21

Merged API improvements from Daniel d'Andrada, including making createPaste async

297. By Ken VanDine on 2016-07-21

Fix from Daniel d'Andrada for memory leak in cuc::Hub::createPaste

298. By Ken VanDine on 2016-07-25

merged trunk

299. By Ken VanDine on 2016-07-25

Added pasteboardChanged signal emitted when the stack has changed

300. By Ken VanDine on 2016-07-27

Merged fixes from dandrader

301. By Ken VanDine on 2016-07-27

Version bump to reflect Pasteboard implemention

302. By Ken VanDine on 2016-07-28

Fix app_id_matches()

303. By Ken VanDine on 2016-07-29

Only check if the appId matches for creating pastes

304. By Ken VanDine on 2016-07-29

spelling

305. By Ken VanDine on 2016-07-29

Only send paste to an app that is currently focused, thanks to Daniel d'Andrada

306. By Ken VanDine on 2016-07-29

Limit stack size to 5

307. By Ken VanDine on 2016-08-01

Remove public API state from Paste

308. By Ken VanDine on 2016-08-01

Don't check isPidFocused from Unity8 while under testing

309. By Ken VanDine on 2016-08-01

Don't register Paste object path when requesting a paste, we control access to that via isPidFocus from Unity8

310. By Ken VanDine on 2016-08-01

Return a bool from CreatePaste and don't register object path during CreatePaste

311. By Ken VanDine on 2016-08-01

removed unneeded handle_pastes

312. By Ken VanDine on 2016-08-03

Updated version

313. By Ken VanDine on 2016-08-03

Ported MimeDataSerialization from qtmir

314. By Ken VanDine on 2016-08-03

Make app_id matches non-fatal for CreatePaste

315. By Ken VanDine on 2016-08-24

merged trunk

316. By Ken VanDine on 2016-08-24

Daniel d'Andrada 2016-08-23 Authenticate using surface ids instead of process ids

317. By Ken VanDine on 2016-08-25

Daniel d'Andrada 2016-08-24 Improve PasteFormatsChanged

Unmerged revisions

=== modified file 'examples/CMakeLists.txt'
--- examples/CMakeLists.txt	2013-08-27 22:15:29 +0000
+++ examples/CMakeLists.txt	2016-06-02 17:19:28 +0000
@@ -16,3 +16,4 @@
 
 add_subdirectory(importer)
 add_subdirectory(exporter)
+add_subdirectory(pasteboard)
 
=== added directory 'examples/pasteboard'
=== added file 'examples/pasteboard/CMakeLists.txt'
--- examples/pasteboard/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ examples/pasteboard/CMakeLists.txt	2016-06-02 17:19:28 +0000
@@ -0,0 +1,55 @@
+# Copyright © 2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authored by: Ken VanDine <[e-mail]>
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+add_executable(
+  copy-to-pasteboard
+
+  copy.cpp
+)
+
+qt5_use_modules(copy-to-pasteboard Core Gui DBus)
+
+set_target_properties(
+  copy-to-pasteboard
+  PROPERTIES
+  AUTOMOC TRUE
+)
+
+target_link_libraries(
+  copy-to-pasteboard
+  content-hub 
+)
+
+add_executable(
+  paste-from-pasteboard
+
+  paste.cpp
+)
+
+qt5_use_modules(paste-from-pasteboard Core Gui DBus)
+
+set_target_properties(
+  paste-from-pasteboard
+  PROPERTIES
+  AUTOMOC TRUE
+)
+
+target_link_libraries(
+  paste-from-pasteboard
+  content-hub 
+)
 
=== added file 'examples/pasteboard/copy.cpp'
--- examples/pasteboard/copy.cpp	1970-01-01 00:00:00 +0000
+++ examples/pasteboard/copy.cpp	2016-06-02 17:19:28 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Ken VanDine <[e-mail]>
+ */
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <QStringList>
+#include <com/ubuntu/content/hub.h>
+#include <com/ubuntu/content/paste.h>
+
+namespace cuc = com::ubuntu::content;
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication a(argc, argv);
+    if (qgetenv("APP_ID").isEmpty()) {
+        qputenv("APP_ID", "copy-to-pasteboard");
+    }
+
+    QString text("Some text");
+
+    if (a.arguments().size() > 1)
+        text = a.arguments().at(1);
+
+    const char * data = text.toStdString().c_str();
+    auto hub = cuc::Hub::Client::instance();
+
+    auto paste = hub->create_paste(data);
+    qDebug() << paste->id() << ":" << text;
+}
 
=== added file 'examples/pasteboard/paste.cpp'
--- examples/pasteboard/paste.cpp	1970-01-01 00:00:00 +0000
+++ examples/pasteboard/paste.cpp	2016-06-02 17:19:28 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Ken VanDine <[e-mail]>
+ */
+
+#include <QCoreApplication>
+#include <QStringList>
+#include <com/ubuntu/content/hub.h>
+
+namespace cuc = com::ubuntu::content;
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication a(argc, argv);
+    if (qgetenv("APP_ID").isEmpty()) {
+        qputenv("APP_ID", "paste-from-pasteboard");
+    }
+
+    QString id("latest");
+
+    if (a.arguments().size() > 1)
+        id = a.arguments().at(1);
+
+    auto hub = cuc::Hub::Client::instance();
+    const char* buf = NULL;
+    if (id == "latest")
+        buf = hub->latest_paste_buf();
+    else
+        buf = hub->paste_buf_by_id(id.toInt());
+    qDebug() << id << ":" << buf;
+    return 0;
+}
 
=== modified file 'import/Ubuntu/Content/CMakeLists.txt'
--- import/Ubuntu/Content/CMakeLists.txt	2015-10-24 00:24:30 +0000
+++ import/Ubuntu/Content/CMakeLists.txt	2016-06-02 17:19:28 +0000
@@ -101,7 +101,7 @@
 endif()
 
 add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/plugins.qmltypes
-    COMMAND ${QT_INSTALL_BINS}/qmlplugindump -notrelocatable Ubuntu.Content 1.1 ../../ > ${CMAKE_CURRENT_BINARY_DIR}/plugins.qmltypes
+    COMMAND ${QT_INSTALL_BINS}/qmlplugindump -noinstantiate -notrelocatable Ubuntu.Content 1.1 ../../ > ${CMAKE_CURRENT_BINARY_DIR}/plugins.qmltypes
     DEPENDS ${PLUGIN}
     WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
 )
 
=== modified file 'include/com/ubuntu/content/hub.h'
--- include/com/ubuntu/content/hub.h	2015-09-29 13:15:58 +0000
+++ include/com/ubuntu/content/hub.h	2016-06-02 17:19:28 +0000
@@ -34,6 +34,7 @@
 class ImportExportHandler;
 class Store;
 class Transfer;
+class Paste;
 
 class Hub : public QObject
 {
@@ -66,6 +67,9 @@
     Q_INVOKABLE virtual Transfer* create_share_to_peer_for_type(Peer peer, Type type);
     Q_INVOKABLE virtual bool has_pending(QString peer_id);
     Q_INVOKABLE virtual Peer peer_for_app_id(QString app_id);
+    Q_INVOKABLE virtual Paste* create_paste(const char * data);
+    Q_INVOKABLE virtual const char* latest_paste_buf();
+    Q_INVOKABLE virtual const char* paste_buf_by_id(int id);
        
   protected:
     Hub(QObject* = nullptr);
 
=== added file 'include/com/ubuntu/content/paste.h'
--- include/com/ubuntu/content/paste.h	1970-01-01 00:00:00 +0000
+++ include/com/ubuntu/content/paste.h	2016-06-02 17:19:28 +0000
@@ -0,0 +1,98 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Ken VanDine <[e-mail]>
+ */
+#ifndef COM_UBUNTU_CONTENT_PASTE_H_
+#define COM_UBUNTU_CONTENT_PASTE_H_
+
+#include <com/ubuntu/content/item.h>
+
+#include <QObject>
+#include <QSharedPointer>
+#include <QVector>
+#include <QString>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace content
+{
+namespace detail
+{
+class Handler;
+}
+}
+}
+}
+
+namespace com
+{
+namespace ubuntu
+{
+namespace content
+{
+class Item;
+
+class Paste : public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(State)
+    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(QString source READ source)
+
+  public:
+    enum State
+    {
+        created,
+        charged,
+        saved,
+        collected,
+        aborted,
+        finalized
+    };
+
+    Paste(const Paste&) = delete;
+    virtual ~Paste();
+
+    Paste& operator=(const Paste&) = delete;
+
+    Q_INVOKABLE virtual int id() const;
+    Q_INVOKABLE virtual State state() const;
+    Q_INVOKABLE virtual bool abort();
+    Q_INVOKABLE virtual bool finalize();
+    Q_INVOKABLE virtual bool charge(const QVector<Item>& items);
+    Q_INVOKABLE virtual QVector<Item> collect();
+    Q_INVOKABLE virtual QString source() const;
+
+    Q_SIGNAL void stateChanged();
+
+  private:
+    struct Private;
+    friend struct Private;
+    friend class Hub;
+    friend class com::ubuntu::content::detail::Handler;
+    QSharedPointer<Private> d;
+
+    Paste(const QSharedPointer<Private>&, QObject* parent = nullptr);    
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_CONTENT_PASTE_H_
 
=== modified file 'src/com/ubuntu/content/CMakeLists.txt'
--- src/com/ubuntu/content/CMakeLists.txt	2015-09-23 14:45:09 +0000
+++ src/com/ubuntu/content/CMakeLists.txt	2016-06-02 17:19:28 +0000
@@ -47,6 +47,13 @@
   detail/transfer.h com::ubuntu::content::detail::Transfer)
 
 qt5_add_dbus_interface(
+  CONTENT_PASTE_STUB ${CMAKE_CURRENT_SOURCE_DIR}/detail/com.ubuntu.content.Paste.xml
+  ContentPasteInterface)
+qt5_add_dbus_adaptor(
+  CONTENT_PASTE_SKELETON ${CMAKE_CURRENT_SOURCE_DIR}/detail/com.ubuntu.content.Paste.xml 
+  detail/paste.h com::ubuntu::content::detail::Paste)
+
+qt5_add_dbus_interface(
   CONTENT_HANDLER_STUB ${CMAKE_CURRENT_SOURCE_DIR}/detail/com.ubuntu.content.Handler.xml 
   ContentHandlerInterface)
 qt5_add_dbus_adaptor(
@@ -56,6 +63,7 @@
 qt5_wrap_cpp(CONTENT_HUB_MOCS ${CMAKE_SOURCE_DIR}/include/com/ubuntu/content/hub.h)
 qt5_wrap_cpp(CONTENT_HUB_MOCS ${CMAKE_SOURCE_DIR}/include/com/ubuntu/content/import_export_handler.h)
 qt5_wrap_cpp(CONTENT_HUB_MOCS ${CMAKE_SOURCE_DIR}/include/com/ubuntu/content/item.h)
+qt5_wrap_cpp(CONTENT_HUB_MOCS ${CMAKE_SOURCE_DIR}/include/com/ubuntu/content/paste.h)
 qt5_wrap_cpp(CONTENT_HUB_MOCS ${CMAKE_SOURCE_DIR}/include/com/ubuntu/content/peer.h)
 qt5_wrap_cpp(CONTENT_HUB_MOCS ${CMAKE_SOURCE_DIR}/include/com/ubuntu/content/store.h)
 qt5_wrap_cpp(CONTENT_HUB_MOCS ${CMAKE_SOURCE_DIR}/include/com/ubuntu/content/transfer.h)
@@ -67,6 +75,7 @@
   hub.cpp
   import_export_handler.cpp
   item.cpp
+  paste.cpp
   peer.cpp
   store.cpp
   transfer.cpp
@@ -75,6 +84,7 @@
   debug.cpp
 
   detail/app_manager.cpp
+  detail/paste.cpp
   detail/service.cpp
   detail/transfer.cpp
   detail/handler.cpp
@@ -83,6 +93,8 @@
   ${CONTENT_HUB_MOCS}
   ${CONTENT_SERVICE_STUB}
   ${CONTENT_SERVICE_SKELETON}
+  ${CONTENT_PASTE_STUB}
+  ${CONTENT_PASTE_SKELETON}
   ${CONTENT_TRANSFER_STUB}
   ${CONTENT_TRANSFER_SKELETON}
   ${CONTENT_HANDLER_STUB}
 
=== added file 'src/com/ubuntu/content/detail/com.ubuntu.content.Paste.xml'
--- src/com/ubuntu/content/detail/com.ubuntu.content.Paste.xml	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/content/detail/com.ubuntu.content.Paste.xml	2016-06-02 17:19:28 +0000
@@ -0,0 +1,26 @@
+<node>
+  <interface name="com.ubuntu.content.dbus.Paste">
+    <signal name="StateChanged">
+      <arg name="state" type="i"/>
+    </signal>
+    <method name="Id">
+      <arg name="id" type="i" direction="out" />
+    </method>
+    <method name="State">
+      <arg name="state" type="i" direction="out" />
+    </method>
+    <method name="Abort">
+    </method>
+    <method name="Finalize">
+    </method>
+    <method name="Charge">
+      <arg name="items" type="av" direction="in" />
+    </method>
+    <method name="Collect">
+      <arg name="items" type="av" direction="out" />
+    </method>
+    <method name="source">
+      <arg name="source" type="s" direction="out" />
+    </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	2015-09-29 13:15:58 +0000
+++ src/com/ubuntu/content/detail/com.ubuntu.content.Service.xml	2016-06-02 17:19:28 +0000
@@ -36,6 +36,19 @@
       <arg name="type_id" type="s" direction="in" />
       <arg name="transfer_object" type="o" direction="out" />
     </method>
+    <method name="CreatePaste">
+      <arg name="app_id" type="s" direction="in" />
+      <arg name="paste_object" type="o" direction="out" />
+    </method>
+    <method name="GetLatestPaste">
+      <arg name="app_id" type="s" direction="in" />
+      <arg name="paste_object" type="o" direction="out" />
+    </method>
+    <method name="GetPaste">
+      <arg name="id" type="s" direction="in" />
+      <arg name="app_id" type="s" direction="in" />
+      <arg name="paste_object" type="o" direction="out" />
+    </method>
     <method name="RegisterImportExportHandler">
       <arg name="peer_id" type="s" direction="in" />
       <arg name="handler_object" type="o" direction="in" />
 
=== added file 'src/com/ubuntu/content/detail/paste.cpp'
--- src/com/ubuntu/content/detail/paste.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/content/detail/paste.cpp	2016-06-02 17:19:28 +0000
@@ -0,0 +1,166 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+
+#include "debug.h"
+#include "paste.h"
+#include "utils.cpp"
+
+#include <QFileInfo>
+#include <com/ubuntu/content/hub.h>
+#include <com/ubuntu/content/store.h>
+#include <com/ubuntu/content/paste.h>
+#include <ubuntu/download_manager/download.h>
+#include <ubuntu/download_manager/manager.h>
+
+namespace cuc = com::ubuntu::content;
+namespace cucd = com::ubuntu::content::detail;
+
+struct cucd::Paste::Private
+{
+    Private(const int id,
+            const QString& source):
+        state(cuc::Paste::created),
+            id(id),
+            source(source)
+    {
+    }
+    
+    cuc::Paste::State state;
+    const int id;
+    const QString source;
+    QString destination;
+    QVariantList items;
+};
+
+cucd::Paste::Paste(const int id,
+                         const QString& source,
+                         QObject* parent) :
+    QObject(parent), d(new Private(id, source))
+{
+    TRACE() << __PRETTY_FUNCTION__;
+}
+
+cucd::Paste::~Paste()
+{
+    TRACE() << __PRETTY_FUNCTION__;
+}
+
+/* unique id of the paste */
+int cucd::Paste::Id()
+{
+    TRACE() << __PRETTY_FUNCTION__;
+    return d->id;
+}
+
+/* returns the add_id of the source app */
+QString cucd::Paste::source()
+{
+    TRACE() << __PRETTY_FUNCTION__;
+    return d->source;
+}
+
+/* returns the add_id of the destination app */
+QString cucd::Paste::destination()
+{
+    TRACE() << __PRETTY_FUNCTION__;
+    if (d->destination.isEmpty())
+        return d->source;
+    return d->destination;
+}
+
+void cucd::Paste::setDestination(QString& dest)
+{
+    TRACE() << __PRETTY_FUNCTION__;
+    d->destination = dest;
+}
+
+/* returns the object path for the paste */
+QString cucd::Paste::path()
+{
+    TRACE() << Q_FUNC_INFO << "destination:" << destination();
+    static const QString path_pattern{"/pastes/%1/%2"};
+    QString path = path_pattern
+            .arg(sanitize_id(destination()))
+            .arg(d->id);
+    return path;
+}
+
+int cucd::Paste::State()
+{
+    TRACE() << __PRETTY_FUNCTION__;
+    return d->state;
+}
+
+void cucd::Paste::Abort()
+{
+    TRACE() << __PRETTY_FUNCTION__;
+
+    if (d->state == cuc::Paste::aborted)
+        return;
+
+    d->items.clear();
+    d->state = cuc::Paste::aborted;
+    Q_EMIT(StateChanged(d->state));
+}
+
+void cucd::Paste::Charge(const QVariantList& items)
+{
+    TRACE() << __PRETTY_FUNCTION__ << "STATE:" << d->state;
+
+    if (d->state == cuc::Paste::charged)
+        return;
+
+    QVariantList ret;
+    Q_FOREACH(QVariant iv, items) {
+        cuc::Item item = qdbus_cast<Item>(iv);
+        ret.append(QVariant::fromValue(item));
+    }
+    if (ret.count() <= 0) {
+        qWarning() << "Failed to charge items, aborting";
+        d->state = cuc::Paste::aborted;
+    } else {
+        d->items = ret;
+        d->state = cuc::Paste::charged;
+    }
+    Q_EMIT(StateChanged(d->state));
+}
+
+QVariantList cucd::Paste::Collect()
+{
+    TRACE() << __PRETTY_FUNCTION__;
+
+    if (d->state != cuc::Paste::collected)
+    {
+        d->state = cuc::Paste::collected;
+        Q_EMIT(StateChanged(d->state));
+    }
+
+    return d->items;
+}
+
+void cucd::Paste::Finalize()
+{
+    TRACE() << __PRETTY_FUNCTION__;
+
+    if (d->state == cuc::Paste::finalized)
+        return;
+
+    d->items.clear();
+    d->state = cuc::Paste::finalized;
+    Q_EMIT(StateChanged(d->state));
+}
 
=== added file 'src/com/ubuntu/content/detail/paste.h'
--- src/com/ubuntu/content/detail/paste.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/content/detail/paste.h	2016-06-02 17:19:28 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Ken VanDine <[e-mail]>
+ */
+#ifndef PASTE_H_
+#define PASTE_H_
+
+#include <QDir>
+#include <QObject>
+#include <QtDBus/QDBusMessage>
+#include <QtDBus/QDBusContext>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace content
+{
+namespace detail
+{
+class Paste : public QObject, protected QDBusContext
+{
+    Q_OBJECT
+    Q_PROPERTY(int State READ State NOTIFY StateChanged)
+    Q_PROPERTY(int id READ Id)
+    Q_PROPERTY(QString source READ source)
+
+  public:
+    Paste(const int, const QString&, QObject* parent = nullptr);
+    Paste(const Paste&) = delete;
+    virtual ~Paste();
+
+    Paste& operator=(const Paste&) = delete;
+
+Q_SIGNALS:
+    void StateChanged(int State);
+
+  public Q_SLOTS:
+    int State();
+    void Charge(const QVariantList&);
+    QVariantList Collect();
+    void Abort();
+    void Finalize();
+    int Id();
+    QString source();
+    QString destination();
+    void setDestination(QString&);
+    QString path();
+
+  private:
+    struct Private;
+    QScopedPointer<Private> d;
+
+};
+}
+}
+}
+}
+
+#endif // PASTE_H_
 
=== modified file 'src/com/ubuntu/content/detail/service.cpp'
--- src/com/ubuntu/content/detail/service.cpp	2016-01-29 17:20:58 +0000
+++ src/com/ubuntu/content/detail/service.cpp	2016-06-02 17:19:28 +0000
@@ -23,6 +23,8 @@
 #include "service.h"
 #include "peer_registry.h"
 #include "i18n.h"
+#include "paste.h"
+#include "pasteadaptor.h"
 #include "transfer.h"
 #include "transferadaptor.h"
 #include "utils.cpp"
@@ -33,6 +35,7 @@
 #include <libnotify/notify.h>
 
 #include <com/ubuntu/content/item.h>
+#include <com/ubuntu/content/paste.h>
 #include <com/ubuntu/content/peer.h>
 #include <com/ubuntu/content/type.h>
 #include <com/ubuntu/content/transfer.h>
@@ -79,6 +82,7 @@
     QDBusConnection connection;
     QSharedPointer<cucd::PeerRegistry> registry;
     QSet<cucd::Transfer*> active_transfers;
+    QList<cucd::Paste*> active_pastes;
     QSet<RegHandler*> handlers;
     QSharedPointer<cua::ApplicationManager> app_manager;
 
@@ -302,6 +306,74 @@
     return CreateTransfer(peer_id, src_id, cuc::Transfer::Share, type_id);
 }
 
+QDBusObjectPath cucd::Service::CreatePaste(const QString& app_id)
+{
+    TRACE() << Q_FUNC_INFO << app_id;
+    static size_t import_counter{0}; import_counter++;
+
+    QUuid uuid{QUuid::createUuid()};
+
+    auto paste = new cucd::Paste(import_counter, app_id, this);
+    new PasteAdaptor(paste);
+    d->active_pastes.append(paste);
+
+    auto path = paste->path();
+    if (not d->connection.registerObject(path, paste))
+        qWarning() << "Problem registering object for path: " << path;
+
+    connect(paste, SIGNAL(StateChanged(int)), this, SLOT(handle_pastes(int)));
+    return QDBusObjectPath{path};
+}
+
+QDBusObjectPath cucd::Service::GetLatestPaste(const QString& app_id)
+{
+    TRACE() << Q_FUNC_INFO << app_id;
+    if (d->active_pastes.isEmpty())
+        return QDBusObjectPath();
+
+    QString dest_id = app_id;
+    if (dest_id.isEmpty())
+    {
+        TRACE() << Q_FUNC_INFO << "APP_ID isnt' set, attempting to get it from AppArmor";
+        dest_id = aa_profile(this->message().service());
+    }
+
+    auto paste = d->active_pastes.last();
+    d->connection.unregisterObject(paste->path());
+    paste->setDestination(dest_id);
+    auto path = paste->path();
+    if (not d->connection.registerObject(path, paste))
+        qWarning() << "Problem registering object for path: " << path;
+    return QDBusObjectPath(paste->path());
+}
+
+QDBusObjectPath cucd::Service::GetPaste(const QString& id, const QString& app_id)
+{
+    TRACE() << Q_FUNC_INFO << id;
+    if (d->active_pastes.isEmpty())
+        return QDBusObjectPath();
+
+    QString dest_id = app_id;
+    if (dest_id.isEmpty())
+    {
+        TRACE() << Q_FUNC_INFO << "APP_ID isnt' set, attempting to get it from AppArmor";
+        dest_id = aa_profile(this->message().service());
+    }
+
+    Q_FOREACH (cucd::Paste *p, d->active_pastes)
+    {
+        if (p->Id() == id.toInt()) {
+            d->connection.unregisterObject(p->path());
+            p->setDestination(dest_id);
+            auto path = p->path();
+            if (not d->connection.registerObject(path, p))
+                qWarning() << "Problem registering object for path: " << path;
+            return QDBusObjectPath(path);
+        }
+    }
+    return QDBusObjectPath();
+}
+
 QDBusObjectPath cucd::Service::CreateTransfer(const QString& dest_id, const QString& src_id, int dir, const QString& type_id)
 {
     TRACE() << Q_FUNC_INFO << "DEST:" << dest_id << "SRC:" << src_id << "DIRECTION:" << dir;
@@ -539,6 +611,29 @@
     }
 }
 
+void cucd::Service::handle_pastes(int state)
+{
+    TRACE() << Q_FUNC_INFO;
+    cucd::Paste *paste = static_cast<cucd::Paste*>(sender());
+    TRACE() << Q_FUNC_INFO << "STATE:" << paste->State();
+
+    if (state == cuc::Paste::charged)
+    {
+        TRACE() << Q_FUNC_INFO << "charged";
+        auto path = paste->path();
+        TRACE() << Q_FUNC_INFO << "Unregistering path:" << path;
+        d->connection.unregisterObject(path);
+    }
+
+    if (state == cuc::Paste::collected)
+    {
+        TRACE() << Q_FUNC_INFO << "collected";
+        auto path = paste->path();
+        TRACE() << Q_FUNC_INFO << "Unregistering path:" << path;
+        d->connection.unregisterObject(path);
+    }
+}
+
 void cucd::Service::handler_unregistered(const QString& s)
 {
     TRACE() << Q_FUNC_INFO << s;
 
=== modified file 'src/com/ubuntu/content/detail/service.h'
--- src/com/ubuntu/content/detail/service.h	2015-09-29 13:15:58 +0000
+++ src/com/ubuntu/content/detail/service.h	2016-06-02 17:19:28 +0000
@@ -61,6 +61,9 @@
     QDBusObjectPath CreateImportFromPeer(const QString&, const QString&, const QString&);
     QDBusObjectPath CreateExportToPeer(const QString&, const QString&, const QString&);
     QDBusObjectPath CreateShareToPeer(const QString&, const QString&, const QString&);
+    QDBusObjectPath CreatePaste(const QString&);
+    QDBusObjectPath GetLatestPaste(const QString&);
+    QDBusObjectPath GetPaste(const QString&, const QString&);
 
     void RegisterImportExportHandler(const QString&, const QDBusObjectPath& handler);
     void HandlerActive(const QString&);
@@ -79,6 +82,7 @@
   private Q_SLOTS:
     void handle_imports(int);
     void handle_exports(int);
+    void handle_pastes(int);
     void handler_unregistered(const QString&);
     QDBusObjectPath CreateTransfer(const QString&, const QString&, int, const QString&);
     void download_notify(com::ubuntu::content::detail::Transfer*);
 
=== modified file 'src/com/ubuntu/content/hub.cpp'
--- src/com/ubuntu/content/hub.cpp	2015-10-23 12:37:24 +0000
+++ src/com/ubuntu/content/hub.cpp	2016-06-02 17:19:28 +0000
@@ -21,6 +21,7 @@
 #include "ContentServiceInterface.h"
 #include "ContentHandlerInterface.h"
 #include "handleradaptor.h"
+#include "paste_p.h"
 #include "transfer_p.h"
 #include "utils.cpp"
 
@@ -331,3 +332,54 @@
     auto peer = reply.value();
     return qdbus_cast<cuc::Peer>(peer.variant());
 }
+
+cuc::Paste* cuc::Hub::create_paste(const char * data) {
+    /* This needs to be replaced with a better way to get the APP_ID */
+    QString id = app_id();
+    TRACE() << Q_FUNC_INFO << id;
+
+    auto reply = d->service->CreatePaste(id);
+    reply.waitForFinished();
+
+    cuc::Paste *paste = cuc::Paste::Private::make_paste(reply.value(), this);
+    auto item = cuc::Item();
+    item.setStream(QByteArray(data));
+    QVector<cuc::Item> items;
+    items << item;
+    paste->charge(items);
+    return paste;
+}
+
+const char* cuc::Hub::latest_paste_buf() {
+    TRACE() << Q_FUNC_INFO;
+    const char* ret = NULL;
+    QString dest_id = app_id();
+    TRACE() << Q_FUNC_INFO << dest_id;
+    auto reply = d->service->GetLatestPaste(dest_id);
+    reply.waitForFinished();
+
+    cuc::Paste *paste = cuc::Paste::Private::make_paste(reply.value(), this);
+    auto items = paste->collect();
+    if (items.count() > 0) {
+        auto item = items.first();
+        ret = item.stream().constData();
+    }
+    return ret;
+}
+
+const char* cuc::Hub::paste_buf_by_id(int id) {
+    TRACE() << Q_FUNC_INFO;
+    const char* ret = NULL;
+    QString dest_id = app_id();
+    auto reply = d->service->GetPaste(QString::number(id), dest_id);
+    reply.waitForFinished();
+
+    cuc::Paste *paste = cuc::Paste::Private::make_paste(reply.value(), this);
+    auto items = paste->collect();
+    if (items.count() > 0) {
+        auto item = items.first();
+        ret = item.stream().constData();
+    }
+    return ret;
+}
+
 
=== added file 'src/com/ubuntu/content/paste.cpp'
--- src/com/ubuntu/content/paste.cpp	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/content/paste.cpp	2016-06-02 17:19:28 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Ken VanDine <[e-mail]>
+ */
+
+#include <com/ubuntu/content/paste.h>
+
+#include "paste_p.h"
+#include "utils.cpp"
+
+namespace cuc = com::ubuntu::content;
+
+cuc::Paste::Paste(const QSharedPointer<cuc::Paste::Private>& d, QObject* parent)
+        : QObject(parent),
+          d(d)
+{
+    QObject::connect(d->remote_paste,
+                SIGNAL (StateChanged(int)),
+                this,
+                SIGNAL (stateChanged()));
+}
+
+cuc::Paste::~Paste()
+{
+    TRACE() << Q_FUNC_INFO;
+}
+
+int cuc::Paste::id() const
+{
+    return d->id();
+}
+
+cuc::Paste::State cuc::Paste::state() const
+{
+    return d->state();
+}
+
+bool cuc::Paste::abort()
+{
+    return d->abort();
+}
+
+bool cuc::Paste::charge(const QVector<cuc::Item>& items)
+{
+    return d->charge(items);
+}
+
+QVector<cuc::Item> cuc::Paste::collect()
+{
+    return d->collect();
+}
+
+bool cuc::Paste::finalize()
+{
+    return d->finalize();
+}
+
+QString cuc::Paste::source() const
+{
+    return d->source();
+}
 
=== added file 'src/com/ubuntu/content/paste_p.h'
--- src/com/ubuntu/content/paste_p.h	1970-01-01 00:00:00 +0000
+++ src/com/ubuntu/content/paste_p.h	2016-06-02 17:19:28 +0000
@@ -0,0 +1,138 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Ken VanDine <[e-mail]>
+ */
+#ifndef COM_UBUNTU_CONTENT_PASTE_P_H_
+#define COM_UBUNTU_CONTENT_PASTE_P_H_
+
+#include "common.h"
+#include "ContentPasteInterface.h"
+
+#include <com/ubuntu/content/item.h>
+#include <com/ubuntu/content/paste.h>
+
+#include <QObject>
+#include <QVector>
+
+namespace com
+{
+namespace ubuntu
+{
+namespace content
+{
+class Paste::Private : public QObject
+{
+    Q_OBJECT
+  public:
+    static Paste* make_paste(const QDBusObjectPath& paste, QObject* parent)
+    {
+        QSharedPointer<Private> d{new Private{paste, parent}};
+        return new Paste{d, parent};
+    }
+
+    Private(const QDBusObjectPath& paste, QObject* parent)
+            : QObject(parent),
+              remote_paste(
+                  new com::ubuntu::content::dbus::Paste(
+                      HUB_SERVICE_NAME,
+                      paste.path(), 
+                      QDBusConnection::sessionBus(), this))
+    {
+    }
+
+    int id()
+    {
+        auto reply = remote_paste->Id();
+        reply.waitForFinished();
+
+        return reply.value();
+    }
+
+    State state()
+    {
+        auto reply = remote_paste->State();
+        reply.waitForFinished();
+
+        if (reply.isError())
+            return Paste::aborted;
+
+        return static_cast<Paste::State>(reply.value());
+    }
+
+    bool abort()
+    {
+        auto reply = remote_paste->Abort();
+        reply.waitForFinished();
+        
+        return not reply.isError();
+    }
+
+    bool finalize()
+    {
+        auto reply = remote_paste->Finalize();
+        reply.waitForFinished();
+
+        return not reply.isError();
+    }
+
+    bool charge(const QVector<Item>& items)
+    {
+        QVariantList itemVariants;
+        Q_FOREACH(const Item& item, items)
+        {
+            itemVariants << QVariant::fromValue(item);
+        }
+        auto reply = remote_paste->Charge(itemVariants);
+        reply.waitForFinished();
+
+        return not reply.isError();
+    }
+
+    QVector<Item> collect()
+    {
+        QVector<Item> result;
+
+        auto reply = remote_paste->Collect();
+        reply.waitForFinished();
+
+        if (reply.isError())
+            return result;
+
+        auto items = reply.value();
+
+        Q_FOREACH(const QVariant& itemVariant, items)
+        {
+            result << qdbus_cast<Item>(itemVariant);
+        }
+
+        return result;
+    }
+
+    QString source()
+    {
+        auto reply = remote_paste->source();
+        reply.waitForFinished();
+
+        return static_cast<QString>(reply.value());
+    }
+
+    com::ubuntu::content::dbus::Paste* remote_paste;
+};
+}
+}
+}
+
+#endif // COM_UBUNTU_CONTENT_PASTE_P_H_
 
=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2015-06-29 13:46:54 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2016-06-02 17:19:28 +0000
@@ -41,6 +41,12 @@
 )
 
 add_executable(
+  app_hub_communication_paste
+  app_hub_communication_paste.cpp
+  ${MOCS}
+)
+
+add_executable(
   app_hub_communication_handler
   app_hub_communication_handler.cpp
   ${MOCS}
@@ -72,6 +78,7 @@
 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_paste 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 Gui DBus Test)
@@ -81,6 +88,7 @@
 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_paste 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_types content-hub gmock gtest gtest_main)
@@ -90,6 +98,7 @@
 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_paste app_hub_communication_transfer)
 add_test(app_hub_communication_handler app_hub_communication_handler)
 add_test(test_utils test_utils)
 add_test(test_types test_types)
 
=== added file 'tests/acceptance-tests/app_hub_communication_paste.cpp'
--- tests/acceptance-tests/app_hub_communication_paste.cpp	1970-01-01 00:00:00 +0000
+++ tests/acceptance-tests/app_hub_communication_paste.cpp	2016-06-02 17:19:28 +0000
@@ -0,0 +1,136 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Ken VanDine <[e-mail]>
+ */
+
+#include "app_manager_mock.h"
+#include "test_harness.h"
+#include "../cross_process_sync.h"
+#include "../fork_and_run.h"
+
+#include <com/ubuntu/content/hub.h>
+#include <com/ubuntu/content/item.h>
+#include <com/ubuntu/content/paste.h>
+
+#include "com/ubuntu/content/detail/peer_registry.h"
+#include "com/ubuntu/content/detail/service.h"
+#include "com/ubuntu/content/serviceadaptor.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <QCoreApplication>
+#include <QtDBus/QDBusConnection>
+#include <QStandardPaths>
+#include <QTemporaryDir>
+#include <QtTest/QTest>
+
+#include <thread>
+
+namespace cua = com::ubuntu::ApplicationManager;
+namespace cuc = com::ubuntu::content;
+namespace cucd = com::ubuntu::content::detail;
+
+void PrintTo(const QString& s, ::std::ostream* os) {
+    *os << std::string(qPrintable(s));
+}
+
+namespace
+{
+QString service_name{"com.ubuntu.content.dbus.Service"};
+
+struct MockedPeerRegistry : public cucd::PeerRegistry
+{
+    MockedPeerRegistry() : cucd::PeerRegistry()
+    {
+        using namespace ::testing;
+
+        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_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));
+    MOCK_METHOD1(peer_is_legacy, bool(QString));
+};
+}
+
+TEST(Hub, transfer_creation_and_states_work)
+{
+    using namespace ::testing;
+
+    test::CrossProcessSync sync;
+    
+    auto parent = [&sync]()
+    {
+        int argc = 0;
+        QCoreApplication app{argc, nullptr};
+
+        QDBusConnection connection = QDBusConnection::sessionBus();        
+        
+        auto mock = new ::testing::NiceMock<MockedPeerRegistry>{};
+        
+        QSharedPointer<cucd::PeerRegistry> registry{mock};
+        auto app_manager = QSharedPointer<cua::ApplicationManager>(new MockedAppManager());
+        cucd::Service implementation(connection, registry, app_manager, &app);
+        new ServiceAdaptor(std::addressof(implementation));
+
+        ASSERT_TRUE(connection.registerService(service_name));
+        ASSERT_TRUE(connection.registerObject("/", std::addressof(implementation)));
+
+        sync.signal_ready();
+
+        app.exec();
+
+        connection.unregisterObject("/");
+        connection.unregisterService(service_name);
+    };
+
+    auto child = [&sync]()
+    {
+        int argc = 0;
+        QCoreApplication app(argc, nullptr);
+
+        sync.wait_for_signal_ready();
+        
+        test::TestHarness harness;
+        harness.add_test_case([]()
+        {
+            qputenv("APP_ID", "some-app");
+            const char * data = "some text";
+            auto hub = cuc::Hub::Client::instance();
+
+            auto paste = hub->create_paste(data);
+            ASSERT_TRUE(paste != nullptr);
+            EXPECT_EQ(QString(data), QString(hub->latest_paste_buf()));
+            EXPECT_EQ(QString(data), QString(hub->paste_buf_by_id(1)));
+
+            hub->quit();
+        });
+        EXPECT_EQ(0, QTest::qExec(std::addressof(harness)));
+    };
+    
+    EXPECT_EQ(EXIT_SUCCESS, test::fork_and_run(child, parent));
+}