Merge lp:~dobey/ubuntu-printing-app/add-notifier-daemon into lp:ubuntu-printing-app

[dobey]

Add notifier daemon.

[Andrew Hayzen (ahayzen)]

Thanks for submitting this!

It looks like translation pot generation was missed, would you be able to add the parts the parts to po/CMakeLists.txt. It looks that all is required is to add --keyword=_ and provide the list of source files.

I've not yet been successful in creating a notification (on both unity7 and unity8), would you be able to provide instructions for how you are testing this?

review: Needs Information

[lp:~dobey/ubuntu-printing-app/add-notifier-daemon]

39. By dobey on 2017-01-26

Add a TESTING document for the notifier.

40. By dobey on 2017-01-26

Guard against a nullptr to avoid crashing if printer doesn't exist.

[dobey (dobey)]

I've added a document to the tree to describe how to test it (as testing cups notifications can be a bit weird to do). I would recommend avoiding having the daemon running in unity 7 as it's not meant for it, and meant to replace the printing indicator for unity 8 session only. (The notification service under unity7 creates a GTK+ dialog that has some additional buttons, for the printer error notifications.)

As for the translations, I had set up the po/ dir already in my branch prior to adding it in yours, and I removed what I had to avoid the conflict. At this point, I think it's probably better to fix that in another branch on top of these (perhaps after they land, as I don't want to get into a weird situation where we keep adding conflicts). There's also some improvements that can be taken from my work here, and applied to the rest of the project tree, now that I see you've added more testing there, but I think that cleanup should happen in another branch too at this point.

[Andrew Hayzen (ahayzen)]

So I've been testing this a bit further and have been able to generate notifications. One thing that I noticed is if the job title is empty then the notification looks a bit strange, it comes up with the following: "" has printed . I'm going to improve the printing app to ensure that it always has some form of title, but I wonder if the notification should also have a fallback ?

[lp:~dobey/ubuntu-printing-app/add-notifier-daemon]

41. By dobey on 2017-02-01

Fix deadlock with deletion of notification in idle timeout.
Remove the two not especially helpful tests.

42. By dobey on 2017-02-01

Remove the unused include.

[Andrew Hayzen (ahayzen)]

The change fixes the deadlock I was having, and I've now been able to confirm notifications appear when using the printing app as well :-)

[Andrew Hayzen (ahayzen)]

This looks good, once the perquisite branch has landed we can land this. I agree that the folder structure of the project can be improved (it came from the SDK template when I only thought the printing-app would be in the code nothing else), we can discuss these improvements after these two branches land.

One thing to note is that the current WIP designs for the printer queue state that on a mobile device when a job is sent to the printer a notification with "Printing on Printer Name" will appear, tapping on that will launch the queue. This is different on desktop, where no notification will be used and just the launcher alert as the queue starts. However these designs are still WIP, so this can be done in a future branch.

review: Approve

[dobey (dobey)]

> One thing to note is that the current WIP designs for the printer queue state
> that on a mobile device when a job is sent to the printer a notification with
> "Printing on Printer Name" will appear, tapping on that will launch the queue.
> This is different on desktop, where no notification will be used and just the
> launcher alert as the queue starts. However these designs are still WIP, so
> this can be done in a future branch.

I've seen no indication that we should have these notifications in one form factor but not another. Nor does it make any sense for that to be the case, IMO, and would be a divergent experience, not a convergent one.

[Andrew Hayzen (ahayzen)]

@dobey, would you mind doing a pull of trunk to bring in the new changes?

Also when trying to get this to build in a silo I got "No package 'properties-cpp' found", which suggests the package libproperties-cpp-dev should be added to the build-deps?

Furthermore when discussing with Bill we have a few changes (these can be done in this branch or a further branch):
1) Currently the text in the notification doesn't wrap, so you only see the first part. Both the design specifications show this (#1.2 in [0] and in [1]). Is this a limitation of the notifications in unity8? or an issue in this notifier code?

2) We don't think there is an API yet for adding an entry for the printer queue into the launcher of unity8 when something is printing without launching an app (what design wants). So for now can you show a notification when something is sent to the printer ("Printing on printerName"), as shown in the design #1.1 in [0]

3) If the user clicks on the notification when something is sent to the printer, this should show the queue dialog. I'm currently building the queue dialog in another branch, not decided on the launcher name yet - will let you know (probably something like ubuntu-queue-dialog, or maybe we could have a url-handler call for it?).

0 - https://docs.google.com/document/d/1QaM9B1LGT5Pcun2bTQT_hgRIGHLjvg-qMe8pSbJcuj4/edit?ts=5808916c&pli=1#heading=h.8ddcj8k35qnq
1 - https://wiki.ubuntu.com/Printing#Printing_succeeds

review: Needs Fixing

[dobey (dobey)]

On Fri, 2017-03-17 at 15:56 +0000, Andrew Hayzen wrote:
> Review: Needs Fixing
>
> @dobey, would you mind doing a pull of trunk to bring in the new
> changes?

I'll get it updated.

> Also when trying to get this to build in a silo I got "No package
> 'properties-cpp' found", which suggests the package libproperties-
> cpp-dev should be added to the build-deps?

I'll see what's going on there.

> Furthermore when discussing with Bill we have a few changes (these
> can be done in this branch or a further branch):
> 1) Currently the text in the notification doesn't wrap, so you only
> see the first part. Both the design specifications show this (#1.2 in
> [0] and in [1]). Is this a limitation of the notifications in unity8?
> or an issue in this notifier code?

This would be an issue on the renderer's side. We have no way to know
what the width of the notification will be on the client (notifier
daemon) side, so we can't do anything about it there. It seems there is
no way to specify how this should be handled, from the client side.

> 2) We don't think there is an API yet for adding an entry for the
> printer queue into the launcher of unity8 when something is printing
> without launching an app (what design wants). So for now can you show
> a notification when something is sent to the printer ("Printing on
> printerName"), as shown in the design #1.1 in [0]

We can't really do this from notifier daemon which listens to cups for
status, no. It would really need to be a notification sent by the
printing app I think, but in 99.9999% of cases will be immediately
followed by the '"foo" has printed." notification. So there's no good
reason to pop a '"foo" is printing." notification immediately prior to.

> 3) If the user clicks on the notification when something is sent to
> the printer, this should show the queue dialog. I'm currently
> building the queue dialog in another branch, not decided on the
> launcher name yet - will let you know (probably something like
> ubuntu-queue-dialog, or maybe we could have a url-handler call for
> it?).

There is no way to implement this as "when the user clicks on the
notification." The design is wrong. To do this would require making the
notification interactive instead, and adding a "View print queue"
button to it.

However, looking at the doc, this is only specified for errors, and
it's specified to go to the printer's page in settings. The notifier
already adds a button to open settings on printer errors, which goes to
settings:///system/printers/${printer_name}. If that's already handled
in system-settings, then I think this is already implemented.

[lp:~dobey/ubuntu-printing-app/add-notifier-daemon]

43. By dobey on 2017-03-17

Merge trunk.

44. By dobey on 2017-03-17

Need properties-cpp.

45. By dobey on 2017-03-17

Use the gdbus module from cmake-extras.

46. By dobey on 2017-03-17

Remove extraneous comment and cmake directory inclusion.

47. By dobey on 2017-03-17

GDbus package is required.

48. By dobey on 2017-03-17

fix typo.

49. By dobey on 2017-03-17

Move the comment to avoid confusing translators.

[Andrew Hayzen (ahayzen)]

OK, thanks for your responses for 1,2,3. I'm going to discuss with Bill our options for them.

I've found one more missing depends that needs to be added, after adding the following package I've been able to build in pbuilder and in a silo :-)
- libnotify-dev

Once the missing depends is fixed, I think this branch is ready and any further changes can be done in further branches :-)

review: Needs Fixing

[lp:~dobey/ubuntu-printing-app/add-notifier-daemon]

50. By dobey on 2017-03-20

Add libnotify-dev to build depends.

[Andrew Hayzen (ahayzen)]

Thanks, this looks good now.

review: Approve

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2017-03-20 13:16:02 +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 13:16:02 +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)
@@ -51,6 +54,7 @@
 
 # Add subdirs
 add_subdirectory(backend)
+add_subdirectory(notifier)
 add_subdirectory(runner)
 add_subdirectory(ubuntu-printing-app)
 
 
=== modified file 'debian/control'
--- debian/control	2017-03-07 15:16:02 +0000
+++ debian/control	2017-03-20 13:16:02 +0000
@@ -3,10 +3,21 @@
 Priority: optional
 Maintainer: Andrew Hayzen <[e-mail]>
 Build-Depends: cmake (>= 2.8.9),
+               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),
+               libnotify-dev,
                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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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 13:16:02 +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"));
+}