Merge lp:~ahayzen/ubuntu-printing-app/rearrange-folders into lp:ubuntu-printing-app

[Andrew Hayzen]

* Move printing app tests into the ubuntu-printing-app folder
* Move backend to ubuntu-printing-app/backend
* Move runner to ubuntu-printing-app/runner
* Remove any trace of click
* Update cmake to respect changes

* Move printing app tests into the ubuntu-printing-app folder
* Move backend to ubuntu-printing-app/backend
* Move runner to ubuntu-printing-app/runner
* Remove any trace of click
* Update cmake to respect changes

[lp:~ahayzen/ubuntu-printing-app/rearrange-folders]

48. By Andrew Hayzen on 2017-03-20

* Rebase onto lp:~dobey/ubuntu-printing-app/add-notifier-daemon

49. By Andrew Hayzen on 2017-03-20

* Rebase onto lp:~dobey/ubuntu-printing-app/fix-i18n

Unmerged revisions

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2017-03-20 10:17:57 +0000
@@ -0,0 +1,5 @@
+CMakeLists.txt.user*
+/build
+/po/Makefile.in.in
+/po/POTFILES.in
+

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2017-03-07 15:01:56 +0000
+++ CMakeLists.txt	2017-03-20 10:17:57 +0000
@@ -1,6 +1,9 @@
 project(ubuntu-printing-app)
 cmake_minimum_required(VERSION 2.8.9)
 
+# Always Be Testing
+enable_testing()
+
 # Load translation tools
 find_program(INTLTOOL_MERGE intltool-merge)
 if(NOT INTLTOOL_MERGE)
@@ -13,15 +16,8 @@
 endif()
 
 # Set the vars
-set(APP_NAME ubuntu-printing-app)
-set(APP_HARDCODE ubuntu-printing-app)
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")  # -fno-permissive -pedantic -Wall -Wextra")
-set(DESKTOP_FILE "${APP_NAME}.desktop")
-set(ICON_FILE ubuntu-printing-app.svg)
-set(MAIN_QML Main.qml)
-set(RUNNER ${APP_HARDCODE})
-set(SNAP_DESKTOP_FILE setup/gui/${DESKTOP_FILE})
 
 # Set the options
 option(SNAP_MODE "Build as a snap package" off)
@@ -34,24 +30,8 @@
 
 include(GNUInstallDirs)
 
-
-# Set the path for the QML files and the backend
-set(UBUNTU_PRINTING_APP_DATA_DIR "${CMAKE_INSTALL_DATADIR}/${APP_HARDCODE}")
-set(MODULE_PATH ${CMAKE_INSTALL_PREFIX}/lib/${CMAKE_LIBRARY_ARCHITECTURE}/${APP_HARDCODE})
-
-# Set the exec path
-if(SNAP_MODE)
-  set(EXEC "APP_ID=${APP_HARDCODE} qmlscene $@ -I $SNAP/${MODULE_PATH} $SNAP/${CMAKE_INSTALL_PREFIX}/${UBUNTU_PRINTING_APP_DATA_DIR}/${MAIN_QML}")
-  set(ICON "$SNAP/${CMAKE_INSTALL_PREFIX}/${UBUNTU_PRINTING_APP_DATA_DIR}/${ICON_FILE}")
-else(SNAP_MODE)
-  set(EXEC "APP_ID=${APP_HARDCODE} qmlscene $@ -I ${MODULE_PATH} ${CMAKE_INSTALL_PREFIX}/${UBUNTU_PRINTING_APP_DATA_DIR}/${MAIN_QML}")
-  set(ICON ${CMAKE_INSTALL_PREFIX}/${UBUNTU_PRINTING_APP_DATA_DIR}/${ICON_FILE})
-endif(SNAP_MODE)
-
-
 # Add subdirs
-add_subdirectory(backend)
-add_subdirectory(runner)
+add_subdirectory(notifier)
 add_subdirectory(ubuntu-printing-app)
 
 # Setup gettext defs and include po directory
@@ -60,17 +40,6 @@
 
 add_subdirectory(po)
 
-# Add tests
-find_package(Qt5Test REQUIRED)
-enable_testing()
-add_subdirectory(tests)
-
-
-# Add run command for QtC
-add_custom_target("run" /usr/bin/qmlscene -I ${CMAKE_BINARY_DIR}/backend  ${CMAKE_SOURCE_DIR}/ubuntu-printing-app/Main.qml
-                  DEPENDS UbuntuPrintingApp UbuntuPrintingAppqmldir
-                  WORKING_DIRECTORY ./ubuntu-printing-app)
-
 # Show files in QtC
 file(GLOB QTC_FILES
      RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}

=== modified file 'debian/control'
--- debian/control	2017-03-07 15:16:02 +0000
+++ debian/control	2017-03-20 10:17:57 +0000
@@ -3,10 +3,21 @@
 Priority: optional
 Maintainer: Andrew Hayzen <[e-mail]>
 Build-Depends: cmake (>= 2.8.9),
+               cmake-extras (>= 0.10),
+               cmake-extras (>= 1.3),
                debhelper (>=9),
                dh-apparmor,
                dh-translations,
+               gcovr,
+               googletest | google-mock,
+               intltool,
+               lcov,
+               libboost-dev,
+               libcups2-dev,
+               libglib2.0-dev (>= 2.35.4),
                libpoppler-qt5-dev,
+               libproperties-cpp-dev,
+               liburl-dispatcher1-dev,
                qmlscene,
                qml-module-qtquick2,
                qml-module-qtquick-layouts,

=== added directory 'notifier'
=== added file 'notifier/CMakeLists.txt'
--- notifier/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ notifier/CMakeLists.txt	2017-03-20 10:17:57 +0000
@@ -0,0 +1,49 @@
+### Install path variables
+include (GNUInstallDirs)
+if (EXISTS "/etc/debian_version") # Workaround for libexecdir on debian
+  set (CMAKE_INSTALL_LIBEXECDIR "${CMAKE_INSTALL_LIBDIR}")
+  set (CMAKE_INSTALL_FULL_LIBEXECDIR "${CMAKE_INSTALL_FULL_LIBDIR}")
+endif ()
+set (CMAKE_INSTALL_PKGLIBEXECDIR "${CMAKE_INSTALL_LIBEXECDIR}/${CMAKE_PROJECT_NAME}")
+set (CMAKE_INSTALL_FULL_PKGLIBEXECDIR "${CMAKE_INSTALL_FULL_LIBEXECDIR}/${CMAKE_PROJECT_NAME}")
+
+### Always Be Testing
+enable_testing()
+
+### Set variables for our binary build targets
+set(SERVICE_LIB_NAME "printing-notifier")
+set(SERVICE_EXEC_NAME "printing-notifier-service")
+
+### Some default compile flags
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2 -g -fPIC")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O2 -g -Wextra -Wall -Werror -Werror=conversion-null -Wno-ignored-qualifiers -fPIC")
+
+### Find deps
+find_package(PkgConfig REQUIRED)
+find_package(Threads)
+
+pkg_check_modules(SERVICE_DEPS REQUIRED
+  gio-unix-2.0>=2.36
+  glib-2.0>=2.36
+  libnotify>=0.7.6
+  properties-cpp
+  url-dispatcher-1
+)
+
+### Find libcups
+find_program(CUPS_CONFIG cups-config)
+execute_process(COMMAND ${CUPS_CONFIG} --cflags OUTPUT_VARIABLE CUPS_CFLAGS OUTPUT_STRIP_TRAILING_WHITESPACE)
+execute_process(COMMAND ${CUPS_CONFIG} --libs OUTPUT_VARIABLE CUPS_LIBS OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+### Add sub-directories
+add_subdirectory(data)
+add_subdirectory(src)
+add_subdirectory(tests)
+
+### Enable coverage reporting
+find_package(CoverageReport)
+ENABLE_COVERAGE_REPORT(
+  TARGETS ${SERVICE_LIB_NAME} ${SERVICE_EXEC_NAME}
+  TESTS test-${SERVICE_LIB_NAME}
+  FILTER /usr/include ${CMAKE_BINARY_DIR}/*
+)

=== added file 'notifier/TESTING'
--- notifier/TESTING	1970-01-01 00:00:00 +0000
+++ notifier/TESTING	2017-03-20 10:17:57 +0000
@@ -0,0 +1,37 @@
+This subtree contains the daemon for notifying of successful print jobs,
+and of issues with the printer when jobs are printed, under Unity 8.
+This document describes how to test some notifications.
+
+
+Testing
+
+0) Make sure the notifier daemon is running:
+
+  $: ./build/notifier/src/printing-notifier-service
+
+1) Add a null printer, if one is not already configured, and enable it:
+
+  $: lpadmin -p nulldevice -E -v file:///dev/null
+  $: cupsenable nulldevice
+
+2) Print a test page:
+
+  $: lpr -P nulldevice -J "Test Page" /usr/share/cups/data/default-testpage.pdf
+
+  The document should "print" immediately, and you should get a notification
+  that reads '"Test Page" has printed."
+
+3) Pause the printer, print another test page, and emit the PrinterStateChanged
+   signal over dbus:
+
+  $: cupsdisable nulldevice
+  $: lpr -P nulldevice -J "Test Page" /usr/share/cups/data/default-testpage.pdf
+  $: gdbus emit -y -o /org/cups/cupsd/Notifier \
+     -s org.cups.cupsd.Notifier.PrinterStateChanged \
+     "Some text" "cups://nulldevice" "nulldevice" 'uint32 0' "toner-low" true
+
+  You should see a notification for the toner being low, with one job
+  queued on the printer. Clicking the OK button should close the notification
+  and perform no further actions. Clicking the "Settings…" button should
+  cause system-settings to open to the settings page for that particular
+  printer.

=== added directory 'notifier/data'
=== added file 'notifier/data/CMakeLists.txt'
--- notifier/data/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ notifier/data/CMakeLists.txt	2017-03-20 10:17:57 +0000
@@ -0,0 +1,48 @@
+##
+##  Systemd Unit File
+##
+
+# where to install
+set (SYSTEMD_USER_DIR "${CMAKE_INSTALL_LIBDIR}/systemd/user")
+message (STATUS "${SYSTEMD_USER_DIR} is the systemd user unit file install dir")
+
+set (SYSTEMD_USER_NAME "${SERVICE_LIB_NAME}.service")
+set (SYSTEMD_USER_FILE "${CMAKE_CURRENT_BINARY_DIR}/${SYSTEMD_USER_NAME}")
+set (SYSTEMD_USER_FILE_IN "${CMAKE_CURRENT_SOURCE_DIR}/${SYSTEMD_USER_NAME}.in")
+
+# build it
+set (pkglibexecdir "${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}")
+configure_file ("${SYSTEMD_USER_FILE_IN}" "${SYSTEMD_USER_FILE}")
+
+# install it
+install (FILES "${SYSTEMD_USER_FILE}"
+         DESTINATION "${SYSTEMD_USER_DIR}")
+
+##
+##  Upstart systemd override Job File
+##
+
+set (UPSTART_SYSTEMD_OVERRIDE_DIR "${CMAKE_INSTALL_FULL_DATADIR}/upstart/systemd-session/upstart")
+message (STATUS "${UPSTART_SYSTEMD_OVERRIDE_DIR} is the Upstart override Job File for systemd dir")
+
+install (FILES "${CMAKE_CURRENT_SOURCE_DIR}/${SERVICE_LIB_NAME}.override"
+         DESTINATION "${UPSTART_SYSTEMD_OVERRIDE_DIR}")
+
+##
+##  Upstart Job File
+##
+
+# where to install
+set (UPSTART_JOB_DIR "${CMAKE_INSTALL_FULL_DATADIR}/upstart/sessions")
+message (STATUS "${UPSTART_JOB_DIR} is the Upstart Job File install dir")
+
+set (UPSTART_JOB_NAME "${SERVICE_LIB_NAME}.conf")
+set (UPSTART_JOB_FILE "${CMAKE_CURRENT_BINARY_DIR}/${UPSTART_JOB_NAME}")
+set (UPSTART_JOB_FILE_IN "${CMAKE_CURRENT_SOURCE_DIR}/${UPSTART_JOB_NAME}.in")
+
+# build it
+configure_file ("${UPSTART_JOB_FILE_IN}" "${UPSTART_JOB_FILE}")
+
+# install it
+install (FILES "${UPSTART_JOB_FILE}"
+         DESTINATION "${UPSTART_JOB_DIR}")

=== added file 'notifier/data/printing-notifier.conf.in'
--- notifier/data/printing-notifier.conf.in	1970-01-01 00:00:00 +0000
+++ notifier/data/printing-notifier.conf.in	2017-03-20 10:17:57 +0000
@@ -0,0 +1,23 @@
+description "Printing Notification Service"
+
+# NOTE: Limiting only to Unity 8 right now as it's still using
+# dbusmenu.  That can be lifted after it is ported to GMenu
+
+start on indicator-services-start
+stop on desktop-end or indicator-services-end
+
+respawn
+respawn limit 2 10
+
+pre-start script
+  # NOTE: Only used on Unity8 today, not 7
+  #       Still allows manual starting
+  if [ "x$DESKTOP_SESSION" != "xubuntu-touch" ] &&
+     [ "x$DESKTOP_SESSION" != "xunity8" ]; then
+    if [ "x$UPSTART_EVENTS" != "x" ] ; then
+      stop; exit 0
+    fi
+  fi
+end script
+
+exec $SNAP@pkglibexecdir@/@SERVICE_EXEC_NAME@

=== added file 'notifier/data/printing-notifier.override'
--- notifier/data/printing-notifier.override	1970-01-01 00:00:00 +0000
+++ notifier/data/printing-notifier.override	2017-03-20 10:17:57 +0000
@@ -0,0 +1,1 @@
+manual

=== added file 'notifier/data/printing-notifier.service.in'
--- notifier/data/printing-notifier.service.in	1970-01-01 00:00:00 +0000
+++ notifier/data/printing-notifier.service.in	2017-03-20 10:17:57 +0000
@@ -0,0 +1,8 @@
+[Unit]
+Description=Printing Notification Service
+PartOf=graphical-session.target
+After=indicators-pre.target
+
+[Service]
+ExecStart=@pkglibexecdir@/@SERVICE_EXEC_NAME@
+Restart=on-failure

=== added directory 'notifier/src'
=== added file 'notifier/src/CMakeLists.txt'
--- notifier/src/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ notifier/src/CMakeLists.txt	2017-03-20 10:17:57 +0000
@@ -0,0 +1,62 @@
+add_definitions(
+  -DGETTEXT_PACKAGE=\"${PROJECT_NAME}\"
+  -DGETTEXT_LOCALEDIR=\"${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LOCALEDIR}\"
+  -DG_LOG_DOMAIN=\"${CMAKE_PROJECT_NAME}\"
+)
+
+include_directories(
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${SERVICE_DEPS_INCLUDE_DIRS}
+)
+link_directories(
+  ${SERVICE_DEPS_LIBRARY_DIRS}
+)
+
+find_package(GDbus REQUIRED)
+add_gdbus_codegen(
+  SERVICE_GENERATED_SOURCES
+  cups-cupsd-notifier
+  org.cups.cupsd
+  ${CMAKE_CURRENT_SOURCE_DIR}/org.cups.cupsd.Notifier.xml)
+
+add_library(${SERVICE_LIB_NAME} STATIC
+  actions.cpp
+  actions.h
+  client.h
+  cups-client.cpp
+  cups-client.h
+  job.h
+  notification.cpp
+  notification.h
+  notify-engine.cpp
+  notify-engine.h
+  printer.h
+  utils.cpp
+  utils.h
+  ${SERVICE_GENERATED_SOURCES}
+)
+
+target_link_libraries(${SERVICE_LIB_NAME}
+  ${SERVICE_DEPS_LIBRARIES}
+  ${CUPS_LIBS}
+)
+
+
+add_executable(${SERVICE_EXEC_NAME}
+  main.cpp
+)
+
+target_link_libraries(${SERVICE_EXEC_NAME}
+  ${SERVICE_LIB_NAME}
+  ${SERVICE_DEPS_LIBRARIES}
+  ${CUPS_LIBS}
+
+  ${CMAKE_THREAD_LIBS_INIT}
+)
+
+install(
+  TARGETS ${SERVICE_EXEC_NAME}
+  RUNTIME
+  DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}/${PROJECT_NAME}
+)

=== added file 'notifier/src/actions.cpp'
--- notifier/src/actions.cpp	1970-01-01 00:00:00 +0000
+++ notifier/src/actions.cpp	2017-03-20 10:17:57 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "actions.h"
+
+#include <glib.h>
+#include <url-dispatcher.h>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+Actions::Actions()
+{
+}
+
+Actions::~Actions()
+{
+}
+
+void Actions::open_settings_app(const std::string& url)
+{
+    g_debug("Dispatching url '%s'", url.c_str());
+    url_dispatch_send(url.c_str(), nullptr, nullptr);
+}
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/actions.h'
--- notifier/src/actions.h	1970-01-01 00:00:00 +0000
+++ notifier/src/actions.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+/**
+ * \brief Interface for all the actions that can be activated by users.
+ *
+ * This is a simple C++ wrapper around our GActionGroup that gets exported
+ * onto the bus. Subclasses implement the actual code that should be run
+ * when a particular action is triggered.
+ */
+class Actions
+{
+public:
+    Actions();
+    virtual ~Actions();
+
+    virtual void open_settings_app(const std::string& url);
+};
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/client.h'
--- notifier/src/client.h	1970-01-01 00:00:00 +0000
+++ notifier/src/client.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include "job.h"
+#include "printer.h"
+
+#include <core/signal.h>
+
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+    class Client {
+    public:
+        Client() = default;
+        virtual ~Client() = default;
+
+        // Signals corresponding to printers
+        virtual core::Signal<const Printer&>& printer_state_changed() = 0;
+
+        // Signals corresponding to jobs
+        virtual core::Signal<const Job&>& job_state_changed() = 0;
+
+        // Methods to manage notification monitoring
+        virtual void create_subscription() = 0;
+        virtual void renew_subscription() = 0;
+        virtual void cancel_subscription() = 0;
+
+        // To iniitalize the notifier with current jobs
+        virtual void refresh() = 0;
+
+    private:
+        // disable copying 
+        Client(const Client&) = delete; 
+        Client& operator=(const Client&) = delete; 
+    };
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/cups-client.cpp'
--- notifier/src/cups-client.cpp	1970-01-01 00:00:00 +0000
+++ notifier/src/cups-client.cpp	2017-03-20 10:17:57 +0000
@@ -0,0 +1,337 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "cups-client.h"
+#include "cups-cupsd-notifier.h"
+
+#include <cups/cups.h>
+
+#include <stdexcept>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+#define NOTIFY_LEASE_DURATION (24 * 60 * 60)
+
+
+class CupsClient::Impl {
+public:
+    Impl()
+    {
+        GError *error = nullptr;
+
+        m_notifier_proxy = notifier_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
+                                                           G_DBUS_PROXY_FLAGS_NONE,
+                                                           nullptr,
+                                                           CUPS_DBUS_PATH,
+                                                           nullptr,
+                                                           &error);
+
+        if (error != nullptr) {
+            std::string msg{"Error creating cups notifier proxy: "};
+            throw std::runtime_error(msg + error->message);
+            g_clear_error(&error);
+        }
+
+        g_object_connect(m_notifier_proxy,
+                         "signal::job-created", on_job_changed, this,
+                         "signal::job-state", on_job_changed, this,
+                         "signal::job-completed", on_job_changed, this,
+                         "signal::printer-state-changed", on_printer_state_changed, this,
+                         nullptr);
+    }
+
+    ~Impl()
+    {
+        if (m_notifier_proxy != nullptr) {
+            g_signal_handlers_disconnect_by_data(m_notifier_proxy, this);
+            g_clear_object(&m_notifier_proxy);
+        }
+
+        // Cancel the subscription from cups, so its notifier can exit.
+        cancel_subscription();
+    }
+
+    // Signals to propagate
+    core::Signal<const Printer&>& printer_state_changed()
+    {
+        return m_printer_state_changed;
+    }
+
+    core::Signal<const Job&>& job_state_changed()
+    {
+        return m_job_state_changed;
+    }
+
+    void create_subscription()
+    {
+        ipp_t *req;
+        ipp_t *resp;
+        ipp_attribute_t *attr;
+
+        req = ippNewRequest (IPP_CREATE_PRINTER_SUBSCRIPTION);
+        ippAddString (req, IPP_TAG_OPERATION, IPP_TAG_URI,
+                      "printer-uri", NULL, "/");
+        ippAddString (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_KEYWORD,
+                      "notify-events", NULL, "all");
+        ippAddString (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
+                      "notify-recipient-uri", NULL, "dbus://");
+        ippAddInteger (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
+                       "notify-lease-duration", NOTIFY_LEASE_DURATION);
+
+        resp = cupsDoRequest (CUPS_HTTP_DEFAULT, req, "/");
+        if (!resp || cupsLastError() != IPP_OK) {
+            g_warning ("Error subscribing to CUPS notifications: %s\n",
+                       cupsLastErrorString ());
+            return;
+        }
+
+        attr = ippFindAttribute (resp, "notify-subscription-id", IPP_TAG_INTEGER);
+        if (attr) {
+            m_subscription_id = ippGetInteger (attr, 0);
+        } else {
+            g_warning ("ipp-create-printer-subscription response doesn't contain "
+                       "subscription id.\n");
+        }
+        ippDelete (resp);
+
+        // Set up to renew the subscription a minute before it expires
+        g_timeout_add_seconds(NOTIFY_LEASE_DURATION - 60,
+                              on_subscription_timeout,
+                              this);
+    }
+
+    void renew_subscription()
+    {
+        ipp_t *req;
+        ipp_t *resp;
+
+        req = ippNewRequest (IPP_RENEW_SUBSCRIPTION);
+        ippAddInteger (req, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                       "notify-subscription-id", m_subscription_id);
+        ippAddString (req, IPP_TAG_OPERATION, IPP_TAG_URI,
+                      "printer-uri", NULL, "/");
+        ippAddString (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_URI,
+                      "notify-recipient-uri", NULL, "dbus://");
+        ippAddInteger (req, IPP_TAG_SUBSCRIPTION, IPP_TAG_INTEGER,
+                       "notify-lease-duration", NOTIFY_LEASE_DURATION);
+
+        resp = cupsDoRequest (CUPS_HTTP_DEFAULT, req, "/");
+        if (!resp || cupsLastError() != IPP_OK) {
+            g_warning ("Error renewing CUPS subscription %d: %s\n",
+                       m_subscription_id, cupsLastErrorString ());
+            create_subscription();
+        }
+
+        ippDelete (resp);
+    }
+
+    void cancel_subscription()
+    {
+        ipp_t *req;
+        ipp_t *resp;
+
+        if (m_subscription_id <= 0) {
+            return;
+        }
+
+        req = ippNewRequest (IPP_CANCEL_SUBSCRIPTION);
+        ippAddString (req, IPP_TAG_OPERATION, IPP_TAG_URI,
+                      "printer-uri", NULL, "/");
+        ippAddInteger (req, IPP_TAG_OPERATION, IPP_TAG_INTEGER,
+                       "notify-subscription-id", m_subscription_id);
+
+        resp = cupsDoRequest (CUPS_HTTP_DEFAULT, req, "/");
+        if (!resp || cupsLastError() != IPP_OK) {
+            g_warning ("Error unsubscribing to CUPS notifications: %s\n",
+                       cupsLastErrorString ());
+            return;
+        }
+
+        ippDelete (resp);
+    }
+
+    void refresh()
+    {
+        int num_dests;
+        cups_dest_t* dests;
+
+        num_dests = cupsGetDests(&dests);
+        for (int i = 0; i < num_dests; i++) {
+            auto printer = get_printer_info(dests[i].name);
+
+            cups_job_t* jobs;
+            const auto num_jobs = cupsGetJobs(&jobs, dests[i].name,
+                                              true, CUPS_WHICHJOBS_ACTIVE);
+            for (int j = 0; j < num_jobs; j++) {
+                Job job;
+                job.id = jobs[j].id;
+                job.state = static_cast<Job::State>(jobs[j].state);
+                job.name = jobs[j].title;
+
+                job.printer = printer;
+
+                m_job_state_changed(job);
+            }
+            cupsFreeJobs(num_jobs, jobs);
+        }
+        cupsFreeDests(num_dests, dests);
+    }
+
+private:
+    // Method to get Printer object from the name
+    Printer get_printer_info(const std::string& name)
+    {
+        int num_dests;
+        cups_dest_t* dests;
+        cups_dest_t* our_dest;
+        Printer printer;
+        printer.name = name;
+
+        num_dests = cupsGetDests(&dests);
+        our_dest = cupsGetDest(name.c_str(), nullptr,
+                               num_dests, dests);
+
+        if (our_dest != nullptr) {
+            // Get the printer's description
+            auto description = cupsGetOption("printer-info",
+                                             our_dest->num_options,
+                                             our_dest->options);
+            if (description != nullptr) {
+                printer.description = description;
+            }
+        }
+
+        cupsFreeDests(num_dests, dests);
+        return printer;
+    }
+ 
+    static gboolean on_subscription_timeout(gpointer gthis)
+    {
+        static_cast<Impl*>(gthis)->renew_subscription();
+        return G_SOURCE_CONTINUE;
+    }
+
+    static void on_job_changed (Notifier*,
+            const char* printer_text,
+            const char* printer_uri,
+            const char *printer_name,
+            unsigned int printer_state,
+            const char *printer_state_reasons,
+            bool printer_is_accepting_jobs,
+            unsigned int job_id,
+            unsigned int job_state,
+            const char *job_state_reasons,
+            const char *job_name,
+            unsigned int job_impressions_completed,
+            gpointer gthis)
+    {
+        auto self = static_cast<Impl*>(gthis);
+
+        auto printer = self->get_printer_info(printer_name);
+        printer.state = static_cast<Printer::State>(printer_state);
+        printer.text = printer_text;
+        printer.uri = printer_uri;
+        printer.state_reasons = printer_state_reasons;
+        printer.accepting_jobs = printer_is_accepting_jobs;
+
+        Job job;
+        job.printer = printer;
+        job.state = static_cast<Job::State>(job_state);
+        job.id = job_id;
+        job.name = job_name;
+        job.state_reasons = job_state_reasons;
+        job.impressions_completed = job_impressions_completed;
+
+        self->m_job_state_changed(job);
+    }
+
+    static void on_printer_state_changed(Notifier*,
+                                         const char* text,
+                                         const char* uri,
+                                         const char* name,
+                                         unsigned int state,
+                                         const char* state_reasons,
+                                         bool is_accepting_jobs,
+                                         gpointer gthis)
+    {
+        auto self = static_cast<Impl*>(gthis);
+
+        auto printer = self->get_printer_info(name);
+        printer.state = static_cast<Printer::State>(state);
+        printer.text = text;
+        printer.uri = uri;
+        printer.state_reasons = state_reasons;
+        printer.accepting_jobs = is_accepting_jobs;
+
+        // Get the number of jobs currently active on the printer
+        cups_job_t* jobs;
+        printer.num_jobs = cupsGetJobs(&jobs, name, true,
+                                       CUPS_WHICHJOBS_ACTIVE);
+        cupsFreeJobs(printer.num_jobs, jobs);
+
+        self->m_printer_state_changed(printer);
+    }
+
+    int m_subscription_id = 0;
+    Notifier* m_notifier_proxy = nullptr;
+    core::Signal<const Printer&> m_printer_state_changed;
+    core::Signal<const Job&> m_job_state_changed;
+};
+
+CupsClient::CupsClient() :
+    p(new Impl())
+{
+}
+
+CupsClient::~CupsClient()
+{
+}
+
+core::Signal<const Printer&>& CupsClient::printer_state_changed()
+{
+    return p->printer_state_changed();
+}
+
+core::Signal<const Job&>& CupsClient::job_state_changed()
+{
+    return p->job_state_changed();
+}
+
+void CupsClient::create_subscription()
+{
+    p->create_subscription();
+}
+
+void CupsClient::renew_subscription()
+{
+    p->renew_subscription();
+}
+
+void CupsClient::cancel_subscription()
+{
+    p->cancel_subscription();
+}
+
+void CupsClient::refresh()
+{
+    p->refresh();
+}
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/cups-client.h'
--- notifier/src/cups-client.h	1970-01-01 00:00:00 +0000
+++ notifier/src/cups-client.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include "client.h"
+#include "job.h"
+#include "printer.h"
+
+#include <core/signal.h>
+
+#include <memory>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+#define CUPS_DBUS_NAME "org.cups.cupsd.Notifier"
+#define CUPS_DBUS_PATH "/org/cups/cupsd/Notifier"
+#define CUPS_DBUS_INTERFACE "org.cups.cupsd.Notifier"
+
+    class CupsClient : public Client {
+    public:
+        CupsClient();
+        virtual ~CupsClient();
+
+        // Signals corresponding to notifier
+        core::Signal<const Printer&>& printer_state_changed() override;
+
+        // Signals corresponding to jobs
+        core::Signal<const Job&>& job_state_changed() override;
+
+        // Methods to manage notification monitoring
+        virtual void create_subscription() override;
+        virtual void renew_subscription() override;
+        virtual void cancel_subscription() override;
+
+        // To initialize the printing with current jobs
+        virtual void refresh() override;
+
+    private:
+        class Impl;
+        std::unique_ptr<Impl> p;
+
+        // disable copying 
+        CupsClient(const CupsClient&) = delete; 
+        CupsClient& operator=(const CupsClient&) = delete; 
+    };
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/dbus-names.h'
--- notifier/src/dbus-names.h	1970-01-01 00:00:00 +0000
+++ notifier/src/dbus-names.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * Authors: Lars Uebernickel <[e-mail]>
+ *
+ * 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#ifndef DBUS_NAMES_H
+#define DBUS_NAMES_H
+
+#define CUPS_DBUS_NAME "org.cups.cupsd.Notifier"
+#define CUPS_DBUS_PATH "/org/cups/cupsd/Notifier"
+#define CUPS_DBUS_INTERFACE "org.cups.cupsd.Notifier"
+
+#endif
+

=== added file 'notifier/src/job.h'
--- notifier/src/job.h	1970-01-01 00:00:00 +0000
+++ notifier/src/job.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include "printer.h"
+
+#include <string>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+    struct Job {
+        // State to match ipp_jstate_t from cups.h
+        typedef enum {
+            PENDING = 3,
+            HELD,
+            PROCESSING,
+            STOPPED,
+            CANCELED,
+            ABORTED,
+            COMPLETED
+        } State;
+        State state = PENDING;
+
+        uint32_t id = 0;
+        std::string name;
+        std::string state_reasons;
+        uint32_t impressions_completed = 0;
+
+        Printer printer;
+    };
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/main.cpp'
--- notifier/src/main.cpp	1970-01-01 00:00:00 +0000
+++ notifier/src/main.cpp	2017-03-20 10:17:57 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "actions.h"
+#include "cups-client.h"
+#include "notify-engine.h"
+#include "utils.h"
+
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+#include <libnotify/notify.h>
+
+using namespace ubuntu::printing::notifier;
+
+int main(int /* argc */, char** argv)
+{
+    // Work around a deadlock in glib's type initialization.
+    // It can be removed when https://bugzilla.gnome.org/show_bug.cgi?id=674885 is fixed.
+    g_type_ensure(G_TYPE_DBUS_CONNECTION);
+
+    // boilerplate i18n
+    setlocale(LC_ALL, "");
+
+    // Need to prepend $SNAP to properly load translations
+    auto localedir = Utilities::prepend_snap_path(GETTEXT_LOCALEDIR);
+    bindtextdomain(GETTEXT_PACKAGE, localedir.c_str());
+    textdomain(GETTEXT_PACKAGE);
+
+    // set up us the machine
+    auto loop = g_main_loop_new(nullptr, false);
+
+    // Initialize notifications, and use program name for app name
+    if (!notify_init(basename(argv[0]))) {
+        g_critical("Unable to initialize libnotify.");
+    }
+ 
+    // create the client and set up the signal handling
+    auto client = std::make_shared<CupsClient>();
+    auto actions = std::make_shared<Actions>();
+    auto engine = std::make_shared<NotifyEngine>(client, actions);
+
+    g_main_loop_run(loop);
+
+    // cleanup
+    notify_uninit();
+    g_main_loop_unref(loop);
+    return 0;
+}

=== added file 'notifier/src/notification.cpp'
--- notifier/src/notification.cpp	1970-01-01 00:00:00 +0000
+++ notifier/src/notification.cpp	2017-03-20 10:17:57 +0000
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "notification.h"
+
+#include <libnotify/notification.h>
+#include <libnotify/notify.h>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+class Notification::Impl
+{
+public:
+    Impl(const std::string& summary,
+         const std::string& body,
+         const std::string& icon_name):
+        m_summary(summary),
+        m_body(body),
+        m_icon_name(icon_name)
+    {
+        m_nn.reset(notify_notification_new(m_summary.c_str(),
+                                           m_body.c_str(),
+                                           m_icon_name.c_str()),
+                   [this](NotifyNotification* n) {
+                       g_signal_handlers_disconnect_by_data(n, this);
+                       g_object_unref(n);
+                   });
+
+        g_signal_connect(m_nn.get(), "closed",
+                         G_CALLBACK(on_notification_closed), this);
+    }
+
+    ~Impl()
+    {
+    }
+
+    core::Signal<const std::string&>& activated()
+    {
+        return m_activated;
+    }
+
+    core::Signal<>& closed()
+    {
+        return m_closed;
+    }
+
+    void add_action(const std::string& action, const std::string& label)
+    {
+        notify_notification_add_action(m_nn.get(),
+                                       action.c_str(), label.c_str(),
+                                       on_notify_activated,
+                                       this, nullptr);
+    }
+
+    void set_hint(const std::string& hint, const std::string& value)
+    {
+        notify_notification_set_hint_string(m_nn.get(),
+                                            hint.c_str(), value.c_str());
+    }
+
+    void close()
+    {
+        if (!notify_is_initted()) {
+            g_warning("Tried to close a notification without notify_init().");
+            return;
+        }
+
+        GError* error = nullptr;
+        notify_notification_close(m_nn.get(), &error);
+
+        if (error != nullptr) {
+            g_critical("Error closing notification: %s", error->message);
+            g_clear_error(&error);
+        }
+    }
+
+    void show()
+    {
+        if (!notify_is_initted()) {
+            g_critical("Unable to display notifications without notify_init().");
+            return;
+        }
+
+        if (m_summary.empty()) {
+            g_critical("Attempting to show notification with no summary!");
+            return;
+        }
+
+        GError* error = nullptr;
+        notify_notification_show(m_nn.get(), &error);
+
+        if (error != nullptr) {
+            g_critical("Error showing notification: %s", error->message);
+            g_clear_error(&error);
+        }
+    }
+
+private:
+    static void on_notify_activated(NotifyNotification*,
+                                    char* action,
+                                    gpointer gthis)
+    {
+        auto self = static_cast<Impl*>(gthis);
+        self->m_activated(action);
+    }
+
+    static void on_notification_closed(NotifyNotification*,
+                                       gpointer gthis)
+    {
+        auto self = static_cast<Impl*>(gthis);
+        g_debug("Notification was closed.");
+        self->m_closed();
+    }
+
+    std::shared_ptr<NotifyNotification> m_nn;
+
+    std::string m_summary;
+    std::string m_body;
+    std::string m_icon_name;
+
+    core::Signal<const std::string&> m_activated;
+    core::Signal<> m_closed;
+};
+
+Notification::Notification(const std::string& summary,
+                           const std::string& body,
+                           const std::string& icon_name):
+    p(new Impl(summary, body, icon_name))
+{
+}
+
+Notification::~Notification()
+{
+}
+
+core::Signal<const std::string&>& Notification::activated()
+{
+    return p->activated();
+}
+
+core::Signal<>& Notification::closed()
+{
+    return p->closed();
+}
+
+void Notification::add_action(const std::string& action,
+                              const std::string& label)
+{
+    p->add_action(action, label);
+}
+
+void Notification::set_hint(const std::string& hint,
+                            const std::string& value)
+{
+    p->set_hint(hint, value);
+}
+
+void Notification::close()
+{
+    p->close();
+}
+
+void Notification::show()
+{
+    p->show();
+}
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/notification.h'
--- notifier/src/notification.h	1970-01-01 00:00:00 +0000
+++ notifier/src/notification.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include <string>
+
+#include <core/signal.h>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+    class Notification {
+    public:
+        Notification(const std::string& summary,
+                     const std::string& body,
+                     const std::string& icon_name);
+        virtual ~Notification();
+
+        // Signal for activation of actions in notification
+        virtual core::Signal<const std::string&>& activated();
+
+        // Signal for forced closing of notification
+        virtual core::Signal<>& closed();
+
+        virtual void add_action(const std::string& action,
+                                const std::string& label);
+
+        // For hints
+        virtual void set_hint(const std::string& hint,
+                              const std::string& value);
+
+        virtual void close();
+        virtual void show();
+
+    private:
+        class Impl;
+        std::unique_ptr<Impl> p;
+
+        // disable copying
+        Notification(const Notification&) = delete;
+        Notification& operator=(const Notification&) = delete;
+    };
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/notify-engine.cpp'
--- notifier/src/notify-engine.cpp	1970-01-01 00:00:00 +0000
+++ notifier/src/notify-engine.cpp	2017-03-20 10:17:57 +0000
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "notify-engine.h"
+
+#include <map>
+#include <regex>
+#include <unordered_set>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/format.hpp>
+
+#include <glib/gi18n.h>
+#include <libnotify/notify.h>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+class NotifyEngine::Impl
+{
+    struct notification_data
+    {
+        std::shared_ptr<Notification> notification;
+        std::unordered_set<std::shared_ptr<Notification>> notifications;
+    };
+
+public:
+    Impl(const std::shared_ptr<Client>& client,
+         const std::shared_ptr<Actions>& actions):
+        m_client(client),
+        m_actions(actions),
+        // NOTE: sorted alphabetically by state
+        m_reasons({
+            {"cover-open", _("A cover is open on the printer “%s”.")},
+            {"cups-missing-filter", _("The printer “%s” can’t be used, because required software is missing.")},
+            {"door-open-report", _("A door is open on the printer “%s”.")},
+            {"media-empty", _("The printer “%s” is out of paper.")},
+            {"media-low", _("The printer “%s” is low on paper.")},
+            {"offline", _("The printer “%s” is currently off-line.")},
+            {"other", _("The printer “%s” has an unknown problem.")},
+            {"toner-empty", _("The printer “%s” is out of toner.")},
+            {"toner-low", _("The printer “%s” is low on toner.")},
+        })
+    {
+    }
+
+    ~Impl()
+    {
+    }
+
+    std::string get_displayable_reason(const std::string& reason)
+    {
+        return m_reasons[reason];
+    }
+
+    std::unordered_set<std::string> get_notified_reasons(const Printer& printer)
+    {
+        return m_notified[printer.name];
+    }
+
+    void set_notified_reasons(const Printer& printer,
+                              std::unordered_set<std::string> reasons)
+    {
+        m_notified[printer.name] = reasons;
+    }
+
+    void show_notification(const std::shared_ptr<Notification>& notification)
+    {
+        if (notification.get() == nullptr) {
+            return;
+        }
+
+        notification->activated().connect([this](const std::string& action) {
+                static const std::regex actionsettings{"^settings:///.*"};
+                if (std::regex_match(action, actionsettings)) {
+                    m_actions->open_settings_app(action);
+                }
+                // Otherwise we just ignore the action.
+            });
+        notification->closed().connect([this, &notification]() {
+                g_debug("Closed notification.");
+                auto data = new notification_data({notification, m_notifications});
+                g_idle_add(on_delete_later, data);
+            });
+        m_notifications.emplace(notification);
+        notification->show();
+    }
+
+private:
+    static gboolean on_delete_later(gpointer gdata)
+    {
+        auto data = static_cast<notification_data*>(gdata);
+        data->notifications.erase(data->notification);
+        return G_SOURCE_REMOVE;
+    }
+
+    std::shared_ptr<Client> m_client;
+    std::shared_ptr<Actions> m_actions;
+
+    // The set of current notifications
+    std::unordered_set<std::shared_ptr<Notification>> m_notifications;
+
+    // The map of "printer" -> set of notified notified states
+    std::map<std::string, std::unordered_set<std::string>> m_notified;
+
+    // The map of "reason" -> _("Translated displayable reason") strings
+    std::map<std::string, std::string> m_reasons;
+}; // class Impl
+
+
+NotifyEngine::NotifyEngine(const std::shared_ptr<Client>& client,
+                           const std::shared_ptr<Actions>& actions):
+    p(new Impl(client, actions))
+{
+    client->job_state_changed().connect([this](const Job& job) {
+            const auto& printer = job.printer;
+            g_debug("State changed for job %u '%s` on printer '%s' and reasons were '%s'",
+                    job.id,
+                    job.name.c_str(),
+                    printer.description.empty() ? printer.name.c_str() : printer.description.c_str(),
+                    job.state_reasons.c_str());
+            if (job.state == Job::State::COMPLETED) {
+                auto notification = build_job_notification(job);
+                p->show_notification(notification);
+            }
+        });
+    client->printer_state_changed().connect([this](const Printer& printer) {
+            g_debug("Printer state changed for reasons: '%s'",
+                    printer.state_reasons.c_str());
+            if (printer.num_jobs > 0) {
+                auto notified = p->get_notified_reasons(printer);
+                std::unordered_set<std::string> reasons;
+                boost::split(reasons, printer.state_reasons, boost::is_any_of(","));
+                for (const auto& reason: reasons) {
+                    if (notified.count(reason) == 0) {
+                        auto notification = build_printer_notification(printer, reason);
+                        p->show_notification(notification);
+                    }
+                }
+                p->set_notified_reasons(printer, reasons);
+            }
+        });
+}
+
+NotifyEngine::~NotifyEngine()
+{
+}
+
+std::shared_ptr<Notification> NotifyEngine::build_job_notification(const Job& job)
+{
+    std::shared_ptr<Notification> notification;
+
+    auto summary = boost::format(_("“%s” has printed.")) % job.name;
+    notification.reset(new Notification(summary.str(), "", NOTIFY_PRINTER_ICON));
+
+    return notification;
+}
+
+std::shared_ptr<Notification> NotifyEngine::build_printer_notification(const Printer& printer,
+                                                                       const std::string& reason)
+{
+    std::shared_ptr<Notification> notification;
+
+    const auto& displayname = printer.description.empty() ? printer.description : printer.name;
+
+    // Get the reason text and add summary/body if valid
+    auto untranslated = p->get_displayable_reason(reason);
+    if (!untranslated.empty()) {
+        auto summary = boost::format(untranslated) % displayname;
+
+        auto jobtext = ngettext("You have %d job queued to print on this printer.", 
+                                "You have %d jobs queued to print on this printer.",
+                                printer.num_jobs);
+        auto body = boost::format(jobtext) % printer.num_jobs;
+
+        notification.reset(new Notification(summary.str(), body.str(), NOTIFY_ERROR_ICON));
+
+        notification->set_hint(NOTIFY_HINT_SNAP, "true");
+        notification->add_action("PRINTER_ACTION_IGNORE", _("OK"));
+        std::string settings_url{"settings:///system/printers/"};
+        notification->add_action(settings_url + printer.name, _("Settings…"));
+    }
+
+    return notification;
+}
+
+
+} //notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/notify-engine.h'
--- notifier/src/notify-engine.h	1970-01-01 00:00:00 +0000
+++ notifier/src/notify-engine.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include "actions.h"
+#include "client.h"
+#include "notification.h"
+
+#include <memory>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+    // Icons for notifications
+    static constexpr const char* NOTIFY_PRINTER_ICON{"printer-symbolic"};
+    static constexpr const char* NOTIFY_ERROR_ICON{"printer-error-symbolic"};
+
+    // Hints for notifications
+    static constexpr const char* NOTIFY_HINT_SNAP{"x-canonical-snap-decisions"};
+
+    class NotifyEngine {
+    public:
+        NotifyEngine(const std::shared_ptr<Client>& client,
+                     const std::shared_ptr<Actions>& actions);
+        virtual ~NotifyEngine();
+
+        virtual std::shared_ptr<Notification> build_job_notification(const Job& job);
+        virtual std::shared_ptr<Notification> build_printer_notification(const Printer& printer,
+                                                                         const std::string& reason);
+
+    private:
+        class Impl;
+        std::unique_ptr<Impl> p;
+
+        // disable copying
+        NotifyEngine(const NotifyEngine&) = delete;
+        NotifyEngine& operator=(const NotifyEngine&) = delete;
+    };
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/org.cups.cupsd.Notifier.xml'
--- notifier/src/org.cups.cupsd.Notifier.xml	1970-01-01 00:00:00 +0000
+++ notifier/src/org.cups.cupsd.Notifier.xml	2017-03-20 10:17:57 +0000
@@ -0,0 +1,147 @@
+<node>
+
+    <interface name="org.cups.cupsd.Notifier">
+
+        <signal name="ServerStarted">
+            <arg type="s" name="text" />
+        </signal>
+
+        <signal name="ServerRestarted">
+            <arg type="s" name="text" />
+        </signal>
+
+        <signal name="ServerStopped">
+            <arg type="s" name="text" />
+        </signal>
+
+        <signal name="ServerAudit">
+            <arg type="s" name="text" />
+        </signal>
+
+        <signal name="PrinterAdded">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+        </signal>
+
+        <signal name="PrinterDeleted">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+        </signal>
+
+        <signal name="PrinterModified">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+        </signal>
+
+        <signal name="PrinterRestarted">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+        </signal>
+
+        <signal name="PrinterStopped">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+        </signal>
+
+        <signal name="PrinterShutdown">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+        </signal>
+
+        <signal name="PrinterStateChanged">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+        </signal>
+
+        <signal name="PrinterFinishingsChanged">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+        </signal>
+
+        <signal name="PrinterMediaChanged">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+        </signal>
+
+        <signal name="JobCreated">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+            <arg type="u" name="job_id" />
+            <arg type="u" name="job_state" />
+            <arg type="s" name="job_state_reasons" />
+            <arg type="s" name="job_name" />
+            <arg type="u" name="job_impressions_completed" />
+        </signal>
+
+        <signal name="JobCompleted">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+            <arg type="u" name="job_id" />
+            <arg type="u" name="job_state" />
+            <arg type="s" name="job_state_reasons" />
+            <arg type="s" name="job_name" />
+            <arg type="u" name="job_impressions_completed" />
+        </signal>
+
+        <signal name="JobState">
+            <arg type="s" name="text" />
+            <arg type="s" name="printer_uri" />
+            <arg type="s" name="printer_name" />
+            <arg type="u" name="printer_state" />
+            <arg type="s" name="printer_state_reasons" />
+            <arg type="b" name="printer_is_accepting_jobs" />
+            <arg type="u" name="job_id" />
+            <arg type="u" name="job_state" />
+            <arg type="s" name="job_state_reasons" />
+            <arg type="s" name="job_name" />
+            <arg type="u" name="job_impressions_completed" />
+        </signal>
+
+    </interface>
+
+</node>
+

=== added file 'notifier/src/printer.h'
--- notifier/src/printer.h	1970-01-01 00:00:00 +0000
+++ notifier/src/printer.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+    struct Printer {
+        // State to match ipp_jstate_t from cups.h
+        typedef enum {
+            IDLE = 3,
+            PROCESSING,
+            STOPPED
+        } State;
+        State state = IDLE;
+
+        std::string name;
+        std::string description;
+        std::string text;
+        std::string uri;
+        std::string state_reasons;
+        bool accepting_jobs = false;
+        uint32_t num_jobs = 0;
+    };
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/utils.cpp'
--- notifier/src/utils.cpp	1970-01-01 00:00:00 +0000
+++ notifier/src/utils.cpp	2017-03-20 10:17:57 +0000
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "utils.h"
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+std::string Utilities::prepend_snap_path(const std::string& path)
+{
+    auto get_snap_path = []() {
+        const char* env_snap = getenv("SNAP");
+        if (env_snap == nullptr) {
+            return "";
+        }
+        return env_snap;
+    };
+    return get_snap_path() + path;
+}
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/src/utils.h'
--- notifier/src/utils.h	1970-01-01 00:00:00 +0000
+++ notifier/src/utils.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+    class Utilities {
+    public:
+        static std::string prepend_snap_path(const std::string& path);
+    };
+
+} // notifier
+} // printing
+} // ubuntu

=== added directory 'notifier/tests'
=== added file 'notifier/tests/CMakeLists.txt'
--- notifier/tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ notifier/tests/CMakeLists.txt	2017-03-20 10:17:57 +0000
@@ -0,0 +1,28 @@
+find_package(GMock REQUIRED)
+
+include_directories(
+  ${CMAKE_SOURCE_DIR}/notifier/src
+  ${SERVICE_DEPS_INCLUDE_DIRS}
+)
+link_directories(
+  ${SERVICE_DEPS_LIBRARY_DIRS}
+)
+
+add_executable(test-${SERVICE_LIB_NAME}
+  actions-mock.h
+  client-mock.h
+  mock-notification.h
+  test_notify-engine.cpp
+  test_utils.cpp
+)
+target_link_libraries(test-${SERVICE_LIB_NAME}
+  ${SERVICE_LIB_NAME}
+  ${SERVICE_DEPS_LIBRARIES}
+  ${CUPS_LIBS}
+
+  ${GTEST_LIBRARIES}
+  ${GMOCK_LIBRARIES}
+
+  ${CMAKE_THREAD_LIBS_INIT}
+)
+add_test(test-${SERVICE_LIB_NAME} test-${SERVICE_LIB_NAME})

=== added file 'notifier/tests/actions-mock.h'
--- notifier/tests/actions-mock.h	1970-01-01 00:00:00 +0000
+++ notifier/tests/actions-mock.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include "actions.h"
+
+#include <gmock/gmock.h>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+    class MockActions: public Actions
+    {
+    public:
+        MockActions():
+            Actions()
+        {
+        }
+
+        ~MockActions() = default;
+
+        MOCK_METHOD1(open_settings_app, void(const std::string&));
+    };
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/tests/client-mock.h'
--- notifier/tests/client-mock.h	1970-01-01 00:00:00 +0000
+++ notifier/tests/client-mock.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#pragma once
+
+#include "client.h"
+
+#include <core/signal.h>
+#include <gmock/gmock.h>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+    class MockClient: public Client
+    {
+    public:
+        explicit MockClient(): Client() {}
+        ~MockClient() = default;
+
+        core::Signal<const Printer&>& printer_state_changed()
+        {
+            return m_printer_state_changed;
+        }
+        core::Signal<const Job&>& job_state_changed()
+        {
+            return m_job_state_changed;
+        }
+
+        MOCK_METHOD0(create_subscription, void());
+        MOCK_METHOD0(renew_subscription, void());
+        MOCK_METHOD0(cancel_subscription, void());
+        MOCK_METHOD0(refresh, void());
+
+        core::Signal<const Printer&> m_printer_state_changed;
+        core::Signal<const Job&> m_job_state_changed;
+    };
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/tests/mock-notification.h'
--- notifier/tests/mock-notification.h	1970-01-01 00:00:00 +0000
+++ notifier/tests/mock-notification.h	2017-03-20 10:17:57 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "notification.h"
+
+#include <core/signal.h>
+#include <gmock/gmock.h>
+
+namespace ubuntu {
+namespace printing {
+namespace notifier {
+
+class MockNotification: public Notification
+{
+ public:
+    MockNotification(const std::string& summary, const std::string& body,
+                     const std::string& icon_name):
+        Notification(summary, body, icon_name)
+    {
+    }
+
+    ~MockNotification()
+    {
+    }
+
+    core::Signal<>& closed()
+    {
+        return m_closed;
+    }
+
+    MOCK_METHOD0(close, void());
+    MOCK_METHOD0(show, void());
+
+    core::Signal<> m_closed;
+};
+
+} // notifier
+} // printing
+} // ubuntu

=== added file 'notifier/tests/test_notify-engine.cpp'
--- notifier/tests/test_notify-engine.cpp	1970-01-01 00:00:00 +0000
+++ notifier/tests/test_notify-engine.cpp	2017-03-20 10:17:57 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "actions-mock.h"
+#include "client-mock.h"
+#include "mock-notification.h"
+#include "notify-engine.h"
+
+#include <memory>
+
+#include <gmock/gmock.h>
+
+using namespace ubuntu::printing::notifier;
+using namespace ::testing;
+
+class EngineFixture: public ::testing::Test
+{
+};
+
+class MockEngine: public NotifyEngine
+{
+public:
+    MockEngine(const std::shared_ptr<Client>& client,
+               const std::shared_ptr<Actions>& actions):
+        NotifyEngine(client, actions)
+    {
+    }
+
+    ~MockEngine()
+    {
+    }
+
+    MOCK_METHOD1(build_job_notification,
+                 std::shared_ptr<Notification>(const Job&));
+    MOCK_METHOD2(build_printer_notification,
+                 std::shared_ptr<Notification>(const Printer&,
+                                               const std::string&));
+};
+
+TEST_F(EngineFixture, NotifyEngine)
+{
+    auto client = std::make_shared<MockClient>();
+    auto actions = std::make_shared<MockActions>();
+
+    // Test for initialization
+    auto engine = std::make_shared<NotifyEngine>(client, actions);
+    ASSERT_FALSE(nullptr == engine);
+
+    // Test refresh
+    EXPECT_CALL(*client, refresh()).Times(1)
+        .WillOnce(Invoke([&client](){
+                    // Notify a printer state change
+                    Printer printer;
+                    printer.name = "a-printer";
+                    printer.description = "A Printer";
+                    printer.accepting_jobs = true;
+                    printer.num_jobs = 1;
+                    printer.state_reasons = "door-open-report";
+                    client->m_printer_state_changed(printer);
+
+                    // Now with 2 reasons
+                    printer.state_reasons = "door-open-report,something-else";
+                    client->m_printer_state_changed(printer);
+
+                    // Notify a COMPLETED job
+                    Job fake_job;
+                    fake_job.id = 42;
+                    fake_job.state = Job::State::COMPLETED;
+                    fake_job.name = "Life, The Universe, and Everything";
+                    fake_job.printer.description = "Deep Thought";
+                    fake_job.printer.name = "deep-thought";
+                    client->m_job_state_changed(fake_job);
+                }));
+    client->refresh();
+}

=== added file 'notifier/tests/test_utils.cpp'
--- notifier/tests/test_utils.cpp	1970-01-01 00:00:00 +0000
+++ notifier/tests/test_utils.cpp	2017-03-20 10:17:57 +0000
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2016-2017 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "utils.h"
+
+#include <gtest/gtest.h>
+
+using namespace ubuntu::printing::notifier;
+
+
+TEST(Utilities, testPrependSnapPathSet) {
+    ASSERT_EQ(0, setenv("SNAP", "/snap", 1));
+    EXPECT_EQ("/snap/bar", Utilities::prepend_snap_path("/bar"));
+    ASSERT_EQ(0, unsetenv("SNAP"));
+}
+
+TEST(Utilities, testPrependSnapPathUnset) {
+    ASSERT_EQ(0, unsetenv("SNAP"));
+    EXPECT_EQ("/bar", Utilities::prepend_snap_path("/bar"));
+}

=== modified file 'po/CMakeLists.txt'
--- po/CMakeLists.txt	2017-01-24 10:58:19 +0000
+++ po/CMakeLists.txt	2017-03-20 10:17:57 +0000
@@ -4,7 +4,7 @@
 find_program(GETTEXT_XGETTEXT_EXECUTABLE xgettext)
 
 file(RELATIVE_PATH DESKTOP_FILE_IN_IN ${CMAKE_SOURCE_DIR}
-     ${CMAKE_SOURCE_DIR}/ubuntu-printing-app/${DESKTOP_FILE}.in.in)
+     ${CMAKE_SOURCE_DIR}/ubuntu-printing-app/${UBUNTU_PRINTING_APP_DESKTOP_FILE}.in.in)
 file(RELATIVE_PATH DESKTOP_FILE_IN_IN_H ${CMAKE_SOURCE_DIR}
      ${CMAKE_CURRENT_SOURCE_DIR}/${DESKTOP_FILE_IN_IN}.h)
 

=== modified file 'po/ubuntu-printing-app.pot'
--- po/ubuntu-printing-app.pot	2017-02-28 15:34:29 +0000
+++ po/ubuntu-printing-app.pot	2017-03-20 10:17:57 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: ubuntu-printing-app\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2017-02-28 15:29+0000\n"
+"POT-Creation-Date: 2017-03-15 11:56+0000\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -45,20 +45,20 @@
 msgid "OK"
 msgstr ""
 
-#: ubuntu-printing-app/components/PrintRow.qml:57
+#: ubuntu-printing-app/components/PrintRow.qml:60
 msgid "Cancel"
 msgstr ""
 
-#: ubuntu-printing-app/components/PrintRow.qml:71
+#: ubuntu-printing-app/components/PrintRow.qml:74
 msgid "Create PDF"
 msgstr ""
 
-#: ubuntu-printing-app/components/PrintRow.qml:71
+#: ubuntu-printing-app/components/PrintRow.qml:74
 #: po/ubuntu-printing-app/ubuntu-printing-app.desktop.in.in.h:1
 msgid "Print"
 msgstr ""
 
-#: ubuntu-printing-app/components/PrintRow.qml:71
+#: ubuntu-printing-app/components/PrintRow.qml:74
 msgid "Sheets"
 msgstr ""
 
@@ -80,50 +80,50 @@
 msgid "Printer Options"
 msgstr ""
 
-#: ubuntu-printing-app/pages/PrintPage.qml:85
+#: ubuntu-printing-app/pages/PrintPage.qml:86
 msgid "Printer"
 msgstr ""
 
-#: ubuntu-printing-app/pages/PrintPage.qml:106
+#: ubuntu-printing-app/pages/PrintPage.qml:107
 msgid "Copies"
 msgstr ""
 
-#: ubuntu-printing-app/pages/PrintPage.qml:129
-msgid "Collate"
-msgstr ""
-
-#: ubuntu-printing-app/pages/PrintPage.qml:149
-msgid "Reverse"
-msgstr ""
-
-#: ubuntu-printing-app/pages/PrintPage.qml:170
+#: ubuntu-printing-app/pages/PrintPage.qml:131
 msgid "All"
 msgstr ""
 
-#: ubuntu-printing-app/pages/PrintPage.qml:170
+#: ubuntu-printing-app/pages/PrintPage.qml:131
 msgid "Range"
 msgstr ""
 
-#: ubuntu-printing-app/pages/PrintPage.qml:174
+#: ubuntu-printing-app/pages/PrintPage.qml:135
 msgid "Pages"
 msgstr ""
 
-#: ubuntu-printing-app/pages/PrintPage.qml:216
+#: ubuntu-printing-app/pages/PrintPage.qml:177
 msgid "eg 1-3,8"
 msgstr ""
 
-#: ubuntu-printing-app/pages/PrintPage.qml:225
+#: ubuntu-printing-app/pages/PrintPage.qml:186
 msgid "Two-sided"
 msgstr ""
 
-#: ubuntu-printing-app/pages/PrintPage.qml:246
+#: ubuntu-printing-app/pages/PrintPage.qml:207
 msgid "Color"
 msgstr ""
 
-#: ubuntu-printing-app/pages/PrintPage.qml:267
+#: ubuntu-printing-app/pages/PrintPage.qml:228
 msgid "Quality"
 msgstr ""
 
+#: ubuntu-printing-app/pages/PrintPage.qml:246
+msgid "Collate"
+msgstr ""
+
+#: ubuntu-printing-app/pages/PrintPage.qml:266
+msgid "Reverse"
+msgstr ""
+
 #: po/ubuntu-printing-app/ubuntu-printing-app.desktop.in.in.h:2
 msgid "Print;Printing;"
 msgstr ""

=== removed directory 'setup'
=== renamed directory 'setup/gui' => 'snap/gui'
=== renamed file 'snapcraft.yaml' => 'snap/snapcraft.yaml'
=== modified file 'ubuntu-printing-app/CMakeLists.txt'
--- ubuntu-printing-app/CMakeLists.txt	2017-01-20 12:36:56 +0000
+++ ubuntu-printing-app/CMakeLists.txt	2017-03-20 10:17:57 +0000
@@ -1,6 +1,34 @@
+set(APP_NAME ubuntu-printing-app)
+set(APP_HARDCODE ubuntu-printing-app)
+set(DESKTOP_FILE "${APP_NAME}.desktop")
+set(ICON_FILE ubuntu-printing-app.svg)
+set(MAIN_QML Main.qml)
+set(RUNNER ${APP_HARDCODE})
+set(SNAP_DESKTOP_FILE snap/gui/${DESKTOP_FILE})
+
+# Set the path for the QML files and the backend
+set(UBUNTU_PRINTING_APP_DATA_DIR "${CMAKE_INSTALL_DATADIR}/${APP_HARDCODE}")
+set(MODULE_PATH ${CMAKE_INSTALL_PREFIX}/lib/${CMAKE_LIBRARY_ARCHITECTURE}/${APP_HARDCODE})
+
+# Set the exec path
+if(SNAP_MODE)
+  set(EXEC "APP_ID=${APP_HARDCODE} qmlscene $@ -I $SNAP/${MODULE_PATH} $SNAP/${CMAKE_INSTALL_PREFIX}/${UBUNTU_PRINTING_APP_DATA_DIR}/${MAIN_QML}")
+  set(ICON "$SNAP/${CMAKE_INSTALL_PREFIX}/${UBUNTU_PRINTING_APP_DATA_DIR}/${ICON_FILE}")
+else(SNAP_MODE)
+  set(EXEC "APP_ID=${APP_HARDCODE} qmlscene $@ -I ${MODULE_PATH} ${CMAKE_INSTALL_PREFIX}/${UBUNTU_PRINTING_APP_DATA_DIR}/${MAIN_QML}")
+  set(ICON ${CMAKE_INSTALL_PREFIX}/${UBUNTU_PRINTING_APP_DATA_DIR}/${ICON_FILE})
+endif(SNAP_MODE)
+
+add_subdirectory(backend)
 add_subdirectory(components)
+add_subdirectory(runner)
 add_subdirectory(pages)
 
+# Add tests
+find_package(Qt5Test REQUIRED)
+enable_testing()
+add_subdirectory(tests)
+
 # Install Main.qml and icon
 install(FILES ${MAIN_QML} DESTINATION ${UBUNTU_PRINTING_APP_DATA_DIR})
 install(FILES ${ICON_FILE} DESTINATION ${UBUNTU_PRINTING_APP_DATA_DIR})
@@ -27,3 +55,6 @@
   file(GLOB MAIN_QML_JS_FILES *.apparmor *.js *.json *.qml)
   add_custom_target(ubuntu_printing_app_main_qml_js_files ALL SOURCES ${MAIN_QML_JS_FILES})
 endif(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+
+# Set variables for use in parent scope
+set(UBUNTU_PRINTING_APP_DESKTOP_FILE "${DESKTOP_FILE}" PARENT_SCOPE)

=== renamed directory 'backend' => 'ubuntu-printing-app/backend'
=== renamed directory 'runner' => 'ubuntu-printing-app/runner'
=== renamed directory 'tests' => 'ubuntu-printing-app/tests'
=== modified file 'ubuntu-printing-app/tests/qmltests/CMakeLists.txt'
--- tests/qmltests/CMakeLists.txt	2017-03-07 14:53:12 +0000
+++ ubuntu-printing-app/tests/qmltests/CMakeLists.txt	2017-03-20 10:17:57 +0000
@@ -18,7 +18,7 @@
 set(TEST tst_QmlTests)
 add_test(${TEST} ${XVFB_COMMAND} ${QMLTESTRUNNER} -qt=qt5
          -input ${CMAKE_CURRENT_SOURCE_DIR}
-         -import ${CMAKE_BINARY_DIR}/backend)
+         -import ${CMAKE_BINARY_DIR}/ubuntu-printing-app/backend)
 
 
 # Add the qml test files to build dir

=== modified file 'ubuntu-printing-app/tests/qmltests/tst_CheckBoxRow.qml'
--- tests/qmltests/tst_CheckBoxRow.qml	2017-01-25 18:13:57 +0000
+++ ubuntu-printing-app/tests/qmltests/tst_CheckBoxRow.qml	2017-03-20 10:17:57 +0000
@@ -20,7 +20,7 @@
 import QtQuick 2.4
 import QtTest 1.1
 import Ubuntu.Test 1.0
-import "../../ubuntu-printing-app/components"
+import "../../components"
 
 Item {
     width: units.gu(100)

=== modified file 'ubuntu-printing-app/tests/qmltests/tst_LabelRow.qml'
--- tests/qmltests/tst_LabelRow.qml	2017-01-25 12:45:05 +0000
+++ ubuntu-printing-app/tests/qmltests/tst_LabelRow.qml	2017-03-20 10:17:57 +0000
@@ -20,7 +20,7 @@
 import QtQuick 2.4
 import QtTest 1.1
 import Ubuntu.Test 1.0
-import "../../ubuntu-printing-app/components"
+import "../../components"
 
 Item {
     width: units.gu(100)

=== modified file 'ubuntu-printing-app/tests/qmltests/tst_PreviewRow.qml'
--- tests/qmltests/tst_PreviewRow.qml	2017-03-08 12:59:51 +0000
+++ ubuntu-printing-app/tests/qmltests/tst_PreviewRow.qml	2017-03-20 10:17:57 +0000
@@ -20,7 +20,7 @@
 import QtQuick 2.4
 import QtTest 1.1
 import Ubuntu.Test 1.0
-import "../../ubuntu-printing-app/components"
+import "../../components"
 
 import UbuntuPrintingApp 1.0
 import Ubuntu.Components.Extras.Printers 0.1

=== modified file 'ubuntu-printing-app/tests/qmltests/tst_PrintPage.qml'
--- tests/qmltests/tst_PrintPage.qml	2017-03-08 12:59:51 +0000
+++ ubuntu-printing-app/tests/qmltests/tst_PrintPage.qml	2017-03-20 10:17:57 +0000
@@ -20,7 +20,7 @@
 import QtQuick 2.4
 import QtTest 1.1
 import Ubuntu.Test 1.0
-import "../../ubuntu-printing-app/pages"
+import "../../pages"
 
 import UbuntuPrintingApp 1.0
 import Ubuntu.Components.Extras.Printers 0.1

=== modified file 'ubuntu-printing-app/tests/qmltests/tst_PrintRow.qml'
--- tests/qmltests/tst_PrintRow.qml	2017-02-17 17:48:28 +0000
+++ ubuntu-printing-app/tests/qmltests/tst_PrintRow.qml	2017-03-20 10:17:57 +0000
@@ -20,7 +20,7 @@
 import QtQuick 2.4
 import QtTest 1.1
 import Ubuntu.Test 1.0
-import "../../ubuntu-printing-app/components"
+import "../../components"
 
 Item {
     width: units.gu(100)

=== modified file 'ubuntu-printing-app/tests/qmltests/tst_SelectorRow.qml'
--- tests/qmltests/tst_SelectorRow.qml	2017-03-07 13:46:02 +0000
+++ ubuntu-printing-app/tests/qmltests/tst_SelectorRow.qml	2017-03-20 10:17:57 +0000
@@ -20,7 +20,7 @@
 import QtQuick 2.4
 import QtTest 1.1
 import Ubuntu.Test 1.0
-import "../../ubuntu-printing-app/components"
+import "../../components"
 
 Item {
     width: units.gu(100)

=== modified file 'ubuntu-printing-app/tests/qmltests/tst_TextFieldRow.qml'
--- tests/qmltests/tst_TextFieldRow.qml	2017-01-25 12:45:05 +0000
+++ ubuntu-printing-app/tests/qmltests/tst_TextFieldRow.qml	2017-03-20 10:17:57 +0000
@@ -20,7 +20,7 @@
 import QtQuick 2.4
 import QtTest 1.1
 import Ubuntu.Test 1.0
-import "../../ubuntu-printing-app/components"
+import "../../components"
 
 Item {
     width: units.gu(100)

=== modified file 'ubuntu-printing-app/tests/unittests/backend/CMakeLists.txt'
--- tests/unittests/backend/CMakeLists.txt	2017-01-27 17:17:01 +0000
+++ ubuntu-printing-app/tests/unittests/backend/CMakeLists.txt	2017-03-20 10:17:57 +0000
@@ -1,7 +1,7 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
-    ${CMAKE_SOURCE_DIR}/backend/
+    ${CMAKE_SOURCE_DIR}/ubuntu-printing-app/backend/
 )
 
 find_package(Qt5Test REQUIRED)