Merge lp:~chipaca/ubuntu-push/the-push-automatic into lp:ubuntu-push

[John Lenton]

Merging automatic:

[ Samuele Pedroni ]
  * Logic to support unregistering tokens lazily for uninstalled apps
  * Minimal wrapping of libclick to check if a package is installed for a user

[ John Lenton ]
  * Finalize dbus api
  * First version of emblem counters.

[John Lenton (chipaca)]

review: Approve

[lp:~chipaca/ubuntu-push/the-push-automatic]

107. By PS Jenkins bot on 2014-07-07

* Logic to support unregistering tokens lazily for uninstalled apps
* Minimal wrapping of libclick to check if a package is installed for a user
* Refactor and cleanup of cleanup/service
* Finalized DBus API (hopefully)
* Support emblem counter notifications
* Support haptic (vibration) notifications
* Support sound notifications

=== modified file 'PACKAGE_DEPS'
--- PACKAGE_DEPS	2014-06-24 14:19:31 +0000
+++ PACKAGE_DEPS	2014-07-07 14:23:18 +0000
@@ -10,3 +10,4 @@
 libwhoopsie-dev
 libmessaging-menu-dev
 libubuntu-app-launch2-dev
+libclick-0.4-dev
 
=== modified file 'bus/connectivity/connectivity.go'
--- bus/connectivity/connectivity.go	2014-04-28 01:56:21 +0000
+++ bus/connectivity/connectivity.go	2014-07-07 14:23:18 +0000
@@ -129,7 +129,7 @@
 		case v, ok := <-cs.networkStateCh:
 			if !ok {
 				// tear it all down and start over
-				return false, errors.New("Got not-OK from StateChanged watch")
+				return false, errors.New("got not-OK from StateChanged watch")
 			}
 			cs.webgetCh = nil
 			cs.currentState = v
 
=== modified file 'bus/connectivity/connectivity_test.go'
--- bus/connectivity/connectivity_test.go	2014-07-01 11:55:30 +0000
+++ bus/connectivity/connectivity_test.go	2014-07-07 14:23:18 +0000
@@ -167,6 +167,7 @@
 func (*racyEndpoint) GrabName(bool) <-chan error                                    { return nil }
 func (*racyEndpoint) WatchMethod(bus.DispatchMap, string, ...interface{})           {}
 func (*racyEndpoint) Signal(member string, suffix string, args []interface{}) error { return nil }
+func (*racyEndpoint) SetProperty(string, string, interface{}) error                 { return nil }
 
 var _ bus.Endpoint = (*racyEndpoint)(nil)
 
 
=== added directory 'bus/emblemcounter'
=== added file 'bus/emblemcounter/emblemcounter.go'
--- bus/emblemcounter/emblemcounter.go	1970-01-01 00:00:00 +0000
+++ bus/emblemcounter/emblemcounter.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,69 @@
+/*
+ Copyright 2014 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/>.
+*/
+
+// Package emblemcounter can present notifications as a counter on an
+// emblem on an item in the launcher.
+package emblemcounter
+
+import (
+	"launchpad.net/go-dbus/v1"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/launch_helper"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/nih"
+)
+
+// emblemcounter works by setting properties on a well-known dbus name.
+var BusAddress = bus.Address{
+	Interface: "com.canonical.Unity.Launcher.Item",
+	Path:      "/com/canonical/Unity/Launcher",
+	Name:      "com.canonical.Unity.Launcher",
+}
+
+// EmblemCounter is a little tool that fiddles with the unity launcher
+// to put emblems with counters on launcher icons.
+type EmblemCounter struct {
+	bus bus.Endpoint
+	log logger.Logger
+}
+
+// Build an EmblemCounter using the given bus and log.
+func New(endp bus.Endpoint, log logger.Logger) *EmblemCounter {
+	return &EmblemCounter{bus: endp, log: log}
+}
+
+// Look for an EmblemCounter section in a Notification and, if
+// present, presents it to the user.
+func (ctr *EmblemCounter) Present(appId string, notificationId string, notification *launch_helper.Notification) {
+	if notification == nil || notification.EmblemCounter == nil {
+		ctr.log.Debugf("no notification or no EmblemCounter in the notification; doing nothing: %#v", notification)
+		return
+	}
+	parsed, err := click.ParseAppId(appId)
+	if err != nil {
+		ctr.log.Debugf("no appId in %#v", appId)
+		return
+	}
+	ec := notification.EmblemCounter
+	ctr.log.Debugf("setting emblem counter for %s to %d (visible: %t)", appId, ec.Count, ec.Visible)
+
+	quoted := string(nih.Quote([]byte(parsed.Application)))
+
+	ctr.bus.SetProperty("count", "/"+quoted, dbus.Variant{ec.Count})
+	ctr.bus.SetProperty("countVisible", "/"+quoted, dbus.Variant{ec.Visible})
+}
 
=== added file 'bus/emblemcounter/emblemcounter_test.go'
--- bus/emblemcounter/emblemcounter_test.go	1970-01-01 00:00:00 +0000
+++ bus/emblemcounter/emblemcounter_test.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,79 @@
+/*
+ Copyright 2014 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/>.
+*/
+
+package emblemcounter
+
+import (
+	"testing"
+
+	"launchpad.net/go-dbus/v1"
+	. "launchpad.net/gocheck"
+
+	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/launch_helper"
+	helpers "launchpad.net/ubuntu-push/testing"
+	"launchpad.net/ubuntu-push/testing/condition"
+)
+
+func TestEmblemCounter(t *testing.T) { TestingT(t) }
+
+type ecSuite struct {
+	log *helpers.TestLogger
+}
+
+var _ = Suite(&ecSuite{})
+
+func (ecs *ecSuite) SetUpTest(c *C) {
+	ecs.log = helpers.NewTestLogger(c, "debug")
+}
+
+// checks that Present() actually calls SetProperty on the launcher
+func (ecs *ecSuite) TestPresentPresents(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+
+	ec := New(endp, ecs.log)
+	notif := launch_helper.Notification{EmblemCounter: &launch_helper.EmblemCounter{Count: 42, Visible: true}}
+	ec.Present("com.example.test_test-app", "nid", &notif)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 2)
+	c.Check(callArgs[0].Member, Equals, "::SetProperty")
+	c.Check(callArgs[1].Member, Equals, "::SetProperty")
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"count", "/test_2dapp", dbus.Variant{Value: int32(42)}})
+	c.Check(callArgs[1].Args, DeepEquals, []interface{}{"countVisible", "/test_2dapp", dbus.Variant{Value: true}})
+}
+
+// check that Present() doesn't call SetProperty if no EmblemCounter in the Notification
+func (ecs *ecSuite) TestSkipIfMissing(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+	ec := New(endp, ecs.log)
+
+	// nothing happens if nil Notification
+	ec.Present("com.example.test_test-app", "nid", nil)
+	c.Assert(testibus.GetCallArgs(endp), HasLen, 0)
+
+	// nothing happens if no EmblemCounter in Notification
+	ec.Present("com.example.test_test-app", "nid", &launch_helper.Notification{})
+	c.Assert(testibus.GetCallArgs(endp), HasLen, 0)
+
+	// but an empty EmblemCounter is acted on
+	ec.Present("com.example.test_test-app", "nid", &launch_helper.Notification{EmblemCounter: &launch_helper.EmblemCounter{}})
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 2)
+	c.Check(callArgs[0].Member, Equals, "::SetProperty")
+	c.Check(callArgs[1].Member, Equals, "::SetProperty")
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"count", "/test_2dapp", dbus.Variant{Value: int32(0)}})
+	c.Check(callArgs[1].Args, DeepEquals, []interface{}{"countVisible", "/test_2dapp", dbus.Variant{Value: false}})
+}
 
=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2014-07-01 11:55:30 +0000
+++ bus/endpoint.go	2014-07-07 14:23:18 +0000
@@ -42,6 +42,7 @@
 	Signal(string, string, []interface{}) error
 	Call(member string, args []interface{}, rvs ...interface{}) error
 	GetProperty(property string) (interface{}, error)
+	SetProperty(property string, suffix string, value interface{}) error
 	Dial() error
 	Close()
 	String() string
@@ -178,6 +179,16 @@
 	return variant.Value, nil
 }
 
+// SetProperty calls org.freedesktop.DBus.Properties's Set method
+//
+// XXX: untested
+func (endp *endpoint) SetProperty(property string, suffix string, value interface{}) error {
+	// can't use the pre-existing ObjectProxy for this one
+	proxy := endp.bus.Object(endp.addr.Name, dbus.ObjectPath(endp.addr.Path+suffix))
+	_, err := proxy.Call("org.freedesktop.DBus.Properties", "Set", endp.addr.Interface, property, value)
+	return err
+}
+
 // Close the connection to dbus.
 //
 // XXX: untested
 
=== added directory 'bus/haptic'
=== added file 'bus/haptic/haptic.go'
--- bus/haptic/haptic.go	1970-01-01 00:00:00 +0000
+++ bus/haptic/haptic.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,70 @@
+/*
+ Copyright 2014 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/>.
+*/
+
+// Package haptic can present notifications as a vibration pattern
+// using the usensord/haptic interface
+package haptic
+
+import (
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/launch_helper"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+// usensord/haptic lives on a well-knwon bus.Address
+var BusAddress bus.Address = bus.Address{
+	Interface: "com.canonical.usensord.haptic",
+	Path:      "/com/canonical/usensord/haptic",
+	Name:      "com.canonical.usensord",
+}
+
+// Haptic encapsulates info needed to call out to usensord/haptic
+type Haptic struct {
+	bus bus.Endpoint
+	log logger.Logger
+}
+
+// New returns a new Haptic that'll use the provided bus.Endpoint
+func New(endp bus.Endpoint, log logger.Logger) *Haptic {
+	return &Haptic{endp, log}
+}
+
+// Present presents the notification via a vibrate pattern
+func (haptic *Haptic) Present(_, _ string, notification *launch_helper.Notification) bool {
+	if notification == nil || notification.Vibrate == nil {
+		haptic.log.Debugf("no notification or no Vibrate in the notification; doing nothing: %#v", notification)
+		return false
+	}
+	pattern := notification.Vibrate.Pattern
+	repeat := notification.Vibrate.Repeat
+	if repeat == 0 {
+		repeat = 1
+	}
+	if notification.Vibrate.Duration != 0 {
+		pattern = []uint32{notification.Vibrate.Duration}
+	}
+	if len(pattern) == 0 {
+		haptic.log.Debugf("not enough information in the notification's Vibrate section to create a pattern")
+		return false
+	}
+	haptic.log.Debugf("vibrating %d times to the tune of %v", repeat, pattern)
+	err := haptic.bus.Call("VibratePattern", bus.Args(pattern, repeat))
+	if err != nil {
+		haptic.log.Debugf("VibratePattern call returned %v", err)
+		return false
+	}
+	return true
+}
 
=== added file 'bus/haptic/haptic_test.go'
--- bus/haptic/haptic_test.go	1970-01-01 00:00:00 +0000
+++ bus/haptic/haptic_test.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,111 @@
+/*
+ Copyright 2014 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/>.
+*/
+
+package haptic
+
+import (
+	"testing"
+
+	. "launchpad.net/gocheck"
+
+	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/launch_helper"
+	helpers "launchpad.net/ubuntu-push/testing"
+	"launchpad.net/ubuntu-push/testing/condition"
+)
+
+func TestHaptic(t *testing.T) { TestingT(t) }
+
+type hapticSuite struct {
+	log *helpers.TestLogger
+}
+
+var _ = Suite(&hapticSuite{})
+
+func (hs *hapticSuite) SetUpTest(c *C) {
+	hs.log = helpers.NewTestLogger(c, "debug")
+}
+
+// checks that Present() actually calls VibratePattern
+func (hs *hapticSuite) TestPresentPresents(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+
+	ec := New(endp, hs.log)
+	notif := launch_helper.Notification{Vibrate: &launch_helper.Vibration{Pattern: []uint32{200, 100}, Repeat: 2}}
+	c.Check(ec.Present("com.example.test_test-app", "nid", &notif), Equals, true)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Check(callArgs[0].Member, Equals, "VibratePattern")
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{[]uint32{200, 100}, uint32(2)})
+}
+
+// check that Present() defaults Repeat to 1
+func (hs *hapticSuite) TestPresentDefaultsRepeatTo1(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+
+	ec := New(endp, hs.log)
+	// note: no Repeat:
+	notif := launch_helper.Notification{Vibrate: &launch_helper.Vibration{Pattern: []uint32{200, 100}}}
+	c.Check(ec.Present("com.example.test_test-app", "nid", &notif), Equals, true)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Check(callArgs[0].Member, Equals, "VibratePattern")
+	// note: Repeat of 1:
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{[]uint32{200, 100}, uint32(1)})
+}
+
+// check that Present() makes a Pattern of [Duration] if Duration is given
+func (hs *hapticSuite) TestPresentBuildsPatternWithDuration(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+
+	ec := New(endp, hs.log)
+	// note: no Repeat, no Pattern, just Duration:
+	notif := launch_helper.Notification{Vibrate: &launch_helper.Vibration{Duration: 200}}
+	c.Check(ec.Present("com.example.test_test-app", "nid", &notif), Equals, true)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Check(callArgs[0].Member, Equals, "VibratePattern")
+	// note: Pattern of [Duration], Repeat of 1:
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{[]uint32{200}, uint32(1)})
+}
+
+// check that Present() ignores Pattern and makes a Pattern of [Duration] if Duration is given
+func (hs *hapticSuite) TestPresentOverrides(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+
+	ec := New(endp, hs.log)
+	// note: Duration given, as well as Pattern; Repeat given as 0:
+	notif := launch_helper.Notification{Vibrate: &launch_helper.Vibration{Duration: 200, Pattern: []uint32{500}, Repeat: 0}}
+	c.Check(ec.Present("com.example.test_test-app", "nid", &notif), Equals, true)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Check(callArgs[0].Member, Equals, "VibratePattern")
+	// note: Pattern of [Duration], Repeat of 1:
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{[]uint32{200}, uint32(1)})
+}
+
+// check that Present() doesn't call VibratePattern if things are not right
+func (hs *hapticSuite) TestSkipIfMissing(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+
+	ec := New(endp, hs.log)
+	// no notification at all
+	c.Check(ec.Present("", "", nil), Equals, false)
+	// no Vibration in the notificaton
+	c.Check(ec.Present("", "", &launch_helper.Notification{}), Equals, false)
+	// empty Vibration
+	c.Check(ec.Present("", "", &launch_helper.Notification{Vibrate: &launch_helper.Vibration{}}), Equals, false)
+}
 
=== modified file 'bus/notifications/app_helper/app_helper_c.go'
--- bus/notifications/app_helper/app_helper_c.go	2014-06-26 17:03:34 +0000
+++ bus/notifications/app_helper/app_helper_c.go	2014-07-07 14:23:18 +0000
@@ -19,23 +19,28 @@
 
 /*
 #cgo pkg-config: gio-unix-2.0
-#cgo pkg-config: gio-2.0
-#include <stdlib.h>
 #include <glib.h>
 #include <gio/gdesktopappinfo.h>
+
+gchar* app_icon_filename_from_id (gchar* app_id) {
+    gchar* filename = NULL;
+    GAppInfo* app_info = (GAppInfo*)g_desktop_app_info_new (app_id);
+    if (app_info != NULL) {
+        GIcon* icon = g_app_info_get_icon (app_info);
+        if (icon != NULL) {
+            filename = g_icon_to_string (icon);
+            // g_app_info_get_icon has "transfer none"
+        }
+        g_object_unref (app_info);
+    }
+   g_free (app_id);
+   return filename;
+}
 */
 import "C"
-import "unsafe"
 
 func AppIconFromId(appId string) string {
-	_id := C.CString(appId)
-	defer C.free(unsafe.Pointer(_id))
-	_app_info := C.g_desktop_app_info_new(_id)
-	defer C.g_app_info_delete(_app_info)
-	_app_icon := C.g_app_info_get_icon(_app_info)
-	defer C.g_object_unref((C.gpointer)(_app_icon))
-	_icon_string := C.g_icon_to_string(_app_icon)
-	defer C.free(unsafe.Pointer(_icon_string))
-	name := C.GoString((*C.char)(_icon_string))
-	return name
+	name := C.app_icon_filename_from_id((*C.gchar)(C.CString(appId)))
+	defer C.g_free((C.gpointer)(name))
+	return C.GoString((*C.char)(name))
 }
 
=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2014-07-01 11:55:30 +0000
+++ bus/testing/testing_endpoint.go	2014-07-07 14:23:18 +0000
@@ -150,6 +150,21 @@
 	return res, err
 }
 
+// See Endpoint's SetProperty. This one does nothing beyond
+// registering being called.
+func (tc *testingEndpoint) SetProperty(property string, suffix string, value interface{}) error {
+	tc.callArgsLck.Lock()
+	defer tc.callArgsLck.Unlock()
+
+	args := callArgs{
+		Member: "::SetProperty",
+		Args:   []interface{}{property, suffix, value},
+	}
+	tc.callArgs = append(tc.callArgs, args)
+
+	return nil
+}
+
 // See Endpoint's Dial. This one will check its dialCondition to
 // decide whether to return an error or not.
 func (endp *testingEndpoint) Dial() error {
 
=== modified file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	2014-07-01 11:55:30 +0000
+++ bus/testing/testing_endpoint_test.go	2014-07-07 14:23:18 +0000
@@ -238,3 +238,14 @@
 			Args:   []interface{}{foomp, []interface{}(nil)},
 		}})
 }
+
+// Test that SetProperty updates callArgs
+func (s *TestingEndpointSuite) TestSetPropertyUpdatesCallArgs(c *C) {
+	endp := NewTestingEndpoint(nil, condition.Work(true))
+	endp.SetProperty("prop", "suffix", "value")
+	c.Check(GetCallArgs(endp), DeepEquals, []callArgs{
+		{
+			Member: "::SetProperty",
+			Args:   []interface{}{"prop", "suffix", "value"},
+		}})
+}
 
=== added directory 'click'
=== added directory 'click/cclick'
=== added file 'click/cclick/cclick.go'
--- click/cclick/cclick.go	1970-01-01 00:00:00 +0000
+++ click/cclick/cclick.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,76 @@
+/*
+ Copyright 2013-2014 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/>.
+*/
+
+// Package cclick has the internal cgo wrapping libclick for package click.
+package cclick
+
+/*
+#cgo pkg-config: click-0.4
+#cgo pkg-config: glib-2.0 gobject-2.0
+
+#include <click-0.4/click.h>
+*/
+import "C"
+
+import (
+	"fmt"
+	"runtime"
+)
+
+type CClickUser struct {
+	cref *C.ClickUser
+}
+
+func gchar(s string) *C.gchar {
+	return (*C.gchar)(C.CString(s))
+}
+
+func gfree(s *C.gchar) {
+	C.g_free((C.gpointer)(s))
+}
+
+func (ccu *CClickUser) CInit(holder interface{}) error {
+	var gerr *C.GError
+	cref := C.click_user_new_for_user(nil, nil, &gerr)
+	defer C.g_clear_error(&gerr)
+	if gerr != nil {
+		return fmt.Errorf("faild to make ClickUser: %s", C.GoString((*C.char)(gerr.message)))
+	}
+	ccu.cref = cref
+	runtime.SetFinalizer(holder, func(interface{}) {
+		C.g_object_unref((C.gpointer)(cref))
+	})
+	return nil
+}
+
+func (ccu *CClickUser) CGetVersion(pkgName string) string {
+	pkgname := gchar(pkgName)
+	defer gfree(pkgname)
+	var gerr *C.GError
+	defer C.g_clear_error(&gerr)
+	ver := C.click_user_get_version(ccu.cref, pkgname, &gerr)
+	if gerr != nil {
+		return ""
+	}
+	defer gfree(ver)
+	return C.GoString((*C.char)(ver))
+}
+
+func (ccu *CClickUser) CHasPackageName(pkgName string) bool {
+	pkgname := gchar(pkgName)
+	defer gfree(pkgname)
+	return C.click_user_has_package_name(ccu.cref, pkgname) == C.TRUE
+}
 
=== added file 'click/click.go'
--- click/click.go	1970-01-01 00:00:00 +0000
+++ click/click.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,86 @@
+/*
+ Copyright 2014 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/>.
+*/
+
+// Package click exposes some utilities related to click packages and
+// wraps libclick to check if packages are installed.
+package click
+
+import (
+	"errors"
+	"regexp"
+	"sync"
+
+	"launchpad.net/ubuntu-push/click/cclick"
+)
+
+// AppId holds a parsed application id.
+type AppId struct {
+	Package     string
+	Application string
+	Version     string
+}
+
+// from https://wiki.ubuntu.com/AppStore/Interfaces/ApplicationId
+// except the version is made optional
+var rx = regexp.MustCompile(`^([a-z0-9][a-z0-9+.-]+)_([a-zA-Z0-9+.-]+)(?:_([0-9][a-zA-Z0-9.+:~-]*))?$`)
+
+var (
+	ErrInvalidAppId = errors.New("invalid application id")
+)
+
+func ParseAppId(id string) (*AppId, error) {
+	m := rx.FindStringSubmatch(id)
+	if len(m) == 0 {
+		return nil, ErrInvalidAppId
+	}
+	return &AppId{Package: m[1], Application: m[2], Version: m[3]}, nil
+}
+
+func AppInPackage(appId, pkgname string) bool {
+	id, _ := ParseAppId(appId)
+	return id != nil && id.Package == pkgname
+}
+
+// ClickUser exposes the click package registry for the user.
+type ClickUser struct {
+	ccu  cclick.CClickUser
+	lock sync.Mutex
+}
+
+// User makes a new ClickUser object for the current user.
+func User() (*ClickUser, error) {
+	cu := new(ClickUser)
+	err := cu.ccu.CInit(cu)
+	if err != nil {
+		return nil, err
+	}
+	return cu, nil
+}
+
+// HasPackage checks if the appId is installed for user.
+func (cu *ClickUser) HasPackage(appId string) bool {
+	cu.lock.Lock()
+	defer cu.lock.Unlock()
+	id, err := ParseAppId(appId)
+	if err != nil {
+		return false
+	}
+	if id.Version != "" {
+		return cu.ccu.CGetVersion(id.Package) == id.Version
+	} else {
+		return cu.ccu.CHasPackageName(id.Package)
+	}
+}
 
=== added file 'click/click_test.go'
--- click/click_test.go	1970-01-01 00:00:00 +0000
+++ click/click_test.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,86 @@
+/*
+ Copyright 2013-2014 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/>.
+*/
+
+package click
+
+import (
+	"testing"
+
+	. "launchpad.net/gocheck"
+)
+
+func TestClick(t *testing.T) { TestingT(t) }
+
+type clickSuite struct{}
+
+var _ = Suite(&clickSuite{})
+
+func (cs *clickSuite) TestParseAppId(c *C) {
+	id, err := ParseAppId("com.ubuntu.clock_clock")
+	c.Assert(err, IsNil)
+	c.Check(id.Package, Equals, "com.ubuntu.clock")
+	c.Check(id.Application, Equals, "clock")
+	c.Check(id.Version, Equals, "")
+
+	id, err = ParseAppId("com.ubuntu.clock_clock_10")
+	c.Assert(err, IsNil)
+	c.Check(id.Package, Equals, "com.ubuntu.clock")
+	c.Check(id.Application, Equals, "clock")
+	c.Check(id.Version, Equals, "10")
+
+	for _, s := range []string{"com.ubuntu.clock_clock_10_4", "com.ubuntu.clock", ""} {
+		id, err = ParseAppId(s)
+		c.Check(id, IsNil)
+		c.Check(err, Equals, ErrInvalidAppId)
+	}
+}
+
+func (cs *clickSuite) TestInPackage(c *C) {
+	c.Check(AppInPackage("com.ubuntu.clock_clock", "com.ubuntu.clock"), Equals, true)
+	c.Check(AppInPackage("com.ubuntu.clock_clock_10", "com.ubuntu.clock"), Equals, true)
+	c.Check(AppInPackage("com.ubuntu.clock", "com.ubuntu.clock"), Equals, false)
+	c.Check(AppInPackage("bananas", "fruit"), Equals, false)
+}
+
+func (s *clickSuite) TestUser(c *C) {
+	u, err := User()
+	c.Assert(err, IsNil)
+	c.Assert(u, NotNil)
+}
+
+func (s *clickSuite) TestHasPackageNegative(c *C) {
+	u, err := User()
+	c.Assert(err, IsNil)
+	c.Check(u.HasPackage("com.foo.bar"), Equals, false)
+	c.Check(u.HasPackage("com.foo.bar_baz"), Equals, false)
+}
+
+func (s *clickSuite) TestHasPackageVersionNegative(c *C) {
+	u, err := User()
+	c.Assert(err, IsNil)
+	c.Check(u.HasPackage("com.ubuntu.clock_clock_1000.0"), Equals, false)
+}
+
+func (s *clickSuite) TestHasPackageClock(c *C) {
+	u, err := User()
+	c.Assert(err, IsNil)
+	ver := u.ccu.CGetVersion("com.ubuntu.clock")
+	if ver == "" {
+		c.Skip("no com.ubuntu.clock pkg installed")
+	}
+	c.Check(u.HasPackage("com.ubuntu.clock_clock"), Equals, true)
+	c.Check(u.HasPackage("com.ubuntu.clock_clock_"+ver), Equals, true)
+}
 
=== modified file 'client/client.go'
--- client/client.go	2014-07-01 11:55:30 +0000
+++ client/client.go	2014-07-07 14:23:18 +0000
@@ -26,16 +26,20 @@
 	"errors"
 	"fmt"
 	"io/ioutil"
+	"net/url"
 	"os"
 	"os/exec"
 	"strings"
 
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/connectivity"
+	"launchpad.net/ubuntu-push/bus/emblemcounter"
+	"launchpad.net/ubuntu-push/bus/haptic"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
 	"launchpad.net/ubuntu-push/bus/notifications"
 	"launchpad.net/ubuntu-push/bus/systemimage"
 	"launchpad.net/ubuntu-push/bus/urldispatcher"
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/client/service"
 	"launchpad.net/ubuntu-push/client/session"
 	"launchpad.net/ubuntu-push/client/session/seenstate"
@@ -68,6 +72,14 @@
 	LogLevel logger.ConfigLogLevel `json:"log_level"`
 }
 
+// PushService is the interface we use of service.PushService.
+type PushService interface {
+	// Start starts the service.
+	Start() error
+	// Unregister unregisters the token for appId.
+	Unregister(appId string) error
+}
+
 // PushClient is the Ubuntu Push Notifications client-side daemon.
 type PushClient struct {
 	leveldbPath           string
@@ -80,6 +92,8 @@
 	notificationsEndp     bus.Endpoint
 	urlDispatcherEndp     bus.Endpoint
 	connectivityEndp      bus.Endpoint
+	emblemcounterEndp     bus.Endpoint
+	hapticEndp            bus.Endpoint
 	systemImageEndp       bus.Endpoint
 	systemImageInfo       *systemimage.InfoResult
 	connCh                chan bool
@@ -88,9 +102,13 @@
 	session               *session.ClientSession
 	sessionConnectedCh    chan uint32
 	pushServiceEndpoint   bus.Endpoint
-	pushService           *service.PushService
+	pushService           PushService
 	postalServiceEndpoint bus.Endpoint
 	postalService         *service.PostalService
+	unregisterCh          chan string
+	trackAddressees       map[string]bool
+	clickUser             *click.ClickUser
+	hasPackage            func(string) bool
 }
 
 // Creates a new Ubuntu Push Notifications client-side daemon that will use
@@ -122,14 +140,26 @@
 	// later, we'll be specifying more logging options in the config file
 	client.log = logger.NewSimpleLogger(os.Stderr, client.config.LogLevel.Level())
 
+	clickUser, err := click.User()
+	if err != nil {
+		return fmt.Errorf("libclick: %v", err)
+	}
+	client.clickUser = clickUser
+	// overridden for testing
+	client.hasPackage = clickUser.HasPackage
+
+	client.unregisterCh = make(chan string, 10)
+
 	// overridden for testing
 	client.idder = identifier.New()
 	client.urlDispatcherEndp = bus.SessionBus.Endpoint(urldispatcher.BusAddress, client.log)
 	client.connectivityEndp = bus.SystemBus.Endpoint(networkmanager.BusAddress, client.log)
 	client.systemImageEndp = bus.SystemBus.Endpoint(systemimage.BusAddress, client.log)
-	if client.notificationsEndp == nil {
-		client.notificationsEndp = bus.SessionBus.Endpoint(notifications.BusAddress, client.log)
-	}
+	client.notificationsEndp = bus.SessionBus.Endpoint(notifications.BusAddress, client.log)
+	client.emblemcounterEndp = bus.SessionBus.Endpoint(emblemcounter.BusAddress, client.log)
+	client.hapticEndp = bus.SessionBus.Endpoint(haptic.BusAddress, client.log)
+	client.postalServiceEndpoint = bus.SessionBus.Endpoint(service.PostalServiceBusAddress, client.log)
+	client.pushServiceEndpoint = bus.SessionBus.Endpoint(service.PushServiceBusAddress, client.log)
 
 	client.connCh = make(chan bool, 1)
 	client.sessionConnectedCh = make(chan uint32, 1)
@@ -156,11 +186,25 @@
 		ExchangeTimeout:        client.config.ExchangeTimeout.TimeDuration(),
 		HostsCachingExpiryTime: client.config.HostsCachingExpiryTime.TimeDuration(),
 		ExpectAllRepairedTime:  client.config.ExpectAllRepairedTime.TimeDuration(),
-		PEM:        client.pem,
-		Info:       info,
-		AuthGetter: client.getAuthorization,
-		AuthURL:    client.config.SessionURL,
-	}
+		PEM:              client.pem,
+		Info:             info,
+		AuthGetter:       client.getAuthorization,
+		AuthURL:          client.config.SessionURL,
+		AddresseeChecker: client,
+	}
+}
+
+// derivePushServiceSetup derives the service setup from the client configuration bits.
+func (client *PushClient) derivePushServiceSetup() (*service.PushServiceSetup, error) {
+	setup := new(service.PushServiceSetup)
+	purl, err := url.Parse(client.config.RegistrationURL)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse registration url: %v", err)
+	}
+	setup.RegURL = purl
+	setup.DeviceId = client.deviceId
+	setup.AuthGetter = client.getAuthorization
+	return setup, nil
 }
 
 // getAuthorization gets the authorization blob to send to the server
@@ -249,6 +293,42 @@
 	}
 }
 
+// StartAddresseeBatch starts a batch of checks for addressees.
+func (client *PushClient) StartAddresseeBatch() {
+	client.trackAddressees = make(map[string]bool, 10)
+}
+
+// CheckForAddressee check for the addressee presence.
+func (client *PushClient) CheckForAddressee(notif *protocol.Notification) bool {
+	appId := notif.AppId
+	present, ok := client.trackAddressees[appId]
+	if ok {
+		return present
+	}
+	present = client.hasPackage(appId)
+	client.trackAddressees[appId] = present
+	if !present {
+		client.unregisterCh <- appId
+	}
+	return present
+}
+
+// handleUnregister deals with tokens of uninstalled apps
+func (client *PushClient) handleUnregister(appId string) {
+	if !client.hasPackage(appId) {
+		// xxx small chance of race here, in case the app gets
+		// reinstalled and registers itself before we finish
+		// the unregister; we need click and app launching
+		// collaboration to do better. we redo the hasPackage
+		// check here just before to keep the race window as
+		// small as possible
+		err := client.pushService.Unregister(appId)
+		if err != nil {
+			client.log.Errorf("unregistering %s: %s", appId, err)
+		}
+	}
+}
+
 // handleConnState deals with connectivity events
 func (client *PushClient) handleConnState(hasConnectivity bool) {
 	if client.hasConnectivity == hasConnectivity {
@@ -320,9 +400,7 @@
 	if !client.filterBroadcastNotification(msg) {
 		return nil
 	}
-	not_id, err := client.postalService.SendNotification(service.ACTION_ID_BROADCAST,
-		"update_manager_icon", "There's an updated system image.",
-		"Tap to open the system updater.")
+	not_id, err := client.postalService.InjectBroadcast()
 	if err != nil {
 		client.log.Errorf("showing notification: %s", err)
 		return err
@@ -333,20 +411,30 @@
 
 // handleUnicastNotification deals with receiving a unicast notification
 func (client *PushClient) handleUnicastNotification(msg *protocol.Notification) error {
+	appId, err := click.ParseAppId(msg.AppId)
+	if err != nil {
+		client.log.Debugf("notification %#v for invalid app id %#v.", msg.MsgId, msg.AppId)
+		return errors.New("invalid app id in notification")
+	}
 	client.log.Debugf("sending notification %#v for %#v.", msg.MsgId, msg.AppId)
-	return client.postalService.Inject(msg.AppId, msg.MsgId, string(msg.Payload))
+	return client.postalService.Inject(appId.Package, msg.AppId, msg.MsgId, string(msg.Payload))
 }
 
 // handleClick deals with the user clicking a notification
-func (client *PushClient) handleClick(action_id string) error {
+func (client *PushClient) handleClick(actionId string) error {
 	// “The string is a stark data structure and everywhere it is passed
 	// there is much duplication of process. It is a perfect vehicle for
 	// hiding information.”
 	//
 	// From ACM's SIGPLAN publication, (September, 1982), Article
 	// "Epigrams in Programming", by Alan J. Perlis of Yale University.
-	url := strings.TrimPrefix(action_id, service.ACTION_ID_SNOWFLAKE)
-	if len(url) == len(action_id) || len(url) == 0 {
+	url := actionId
+	// XXX: branch for the broadcast notifications
+	if strings.HasPrefix(actionId, service.ACTION_ID_PREFIX) {
+		parts := strings.Split(actionId, "::")
+		url = parts[1]
+	}
+	if len(url) == len(actionId) || len(url) == 0 {
 		// it didn't start with the prefix
 		return nil
 	}
@@ -356,7 +444,7 @@
 }
 
 // doLoop connects events with their handlers
-func (client *PushClient) doLoop(connhandler func(bool), clickhandler func(string) error, bcasthandler func(*session.BroadcastNotification) error, ucasthandler func(*protocol.Notification) error, errhandler func(error)) {
+func (client *PushClient) doLoop(connhandler func(bool), clickhandler func(string) error, bcasthandler func(*session.BroadcastNotification) error, ucasthandler func(*protocol.Notification) error, errhandler func(error), unregisterhandler func(string)) {
 	for {
 		select {
 		case state := <-client.connCh:
@@ -371,6 +459,8 @@
 			errhandler(err)
 		case count := <-client.sessionConnectedCh:
 			client.log.Debugf("Session connected after %d attempts", count)
+		case appId := <-client.unregisterCh:
+			unregisterhandler(appId)
 		}
 	}
 }
@@ -392,21 +482,17 @@
 		client.handleClick,
 		client.handleBroadcastNotification,
 		client.handleUnicastNotification,
-		client.handleErr)
+		client.handleErr,
+		client.handleUnregister)
 }
 
 func (client *PushClient) startService() error {
-	if client.pushServiceEndpoint == nil {
-		client.pushServiceEndpoint = bus.SessionBus.Endpoint(service.PushServiceBusAddress, client.log)
-	}
-	if client.postalServiceEndpoint == nil {
-		client.postalServiceEndpoint = bus.SessionBus.Endpoint(service.PostalServiceBusAddress, client.log)
+	setup, err := client.derivePushServiceSetup()
+	if err != nil {
+		return err
 	}
 
-	client.pushService = service.NewPushService(client.pushServiceEndpoint, client.log)
-	client.pushService.SetRegistrationURL(client.config.RegistrationURL)
-	client.pushService.SetAuthGetter(client.getAuthorization)
-	client.pushService.SetDeviceId(client.deviceId)
+	client.pushService = service.NewPushService(client.pushServiceEndpoint, setup, client.log)
 	if err := client.pushService.Start(); err != nil {
 		return err
 	}
@@ -414,10 +500,7 @@
 }
 
 func (client *PushClient) setupPostalService() error {
-	if client.notificationsEndp == nil {
-		client.notificationsEndp = bus.SessionBus.Endpoint(notifications.BusAddress, client.log)
-	}
-	client.postalService = service.NewPostalService(client.postalServiceEndpoint, client.notificationsEndp, client.log)
+	client.postalService = service.NewPostalService(client.postalServiceEndpoint, client.notificationsEndp, client.emblemcounterEndp, client.hapticEndp, client.log)
 	return nil
 }
 
 
=== modified file 'client/client_test.go'
--- client/client_test.go	2014-07-01 11:55:30 +0000
+++ client/client_test.go	2014-07-07 14:23:18 +0000
@@ -187,14 +187,26 @@
 
 func (cs *clientSuite) TestConfigureSetsUpEndpoints(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+
+	// keep these in the same order as in the client struct, for sanity
 	c.Check(cli.notificationsEndp, IsNil)
 	c.Check(cli.urlDispatcherEndp, IsNil)
 	c.Check(cli.connectivityEndp, IsNil)
+	c.Check(cli.emblemcounterEndp, IsNil)
+	c.Check(cli.hapticEndp, IsNil)
+	c.Check(cli.systemImageEndp, IsNil)
+	c.Check(cli.pushServiceEndpoint, IsNil)
+	c.Check(cli.postalServiceEndpoint, IsNil)
 	err := cli.configure()
 	c.Assert(err, IsNil)
-	c.Assert(cli.notificationsEndp, NotNil)
-	c.Assert(cli.urlDispatcherEndp, NotNil)
-	c.Assert(cli.connectivityEndp, NotNil)
+	c.Check(cli.notificationsEndp, NotNil)
+	c.Check(cli.urlDispatcherEndp, NotNil)
+	c.Check(cli.connectivityEndp, NotNil)
+	c.Check(cli.emblemcounterEndp, NotNil)
+	c.Check(cli.hapticEndp, NotNil)
+	c.Check(cli.systemImageEndp, NotNil)
+	c.Check(cli.pushServiceEndpoint, NotNil)
+	c.Check(cli.postalServiceEndpoint, NotNil)
 }
 
 func (cs *clientSuite) TestConfigureSetsUpConnCh(c *C) {
@@ -205,6 +217,15 @@
 	c.Assert(cli.connCh, NotNil)
 }
 
+func (cs *clientSuite) TestConfigureSetsUpAddresseeChecks(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	c.Check(cli.unregisterCh, IsNil)
+	err := cli.configure()
+	c.Assert(err, IsNil)
+	c.Assert(cli.unregisterCh, NotNil)
+	c.Assert(cli.hasPackage("com.bar.baz_foo"), Equals, false)
+}
+
 func (cs *clientSuite) TestConfigureBailsOnBadFilename(c *C) {
 	cli := NewPushClient("/does/not/exist", cs.leveldbPath)
 	err := cli.configure()
@@ -255,6 +276,35 @@
 }
 
 /*****************************************************************
+    addresses checking tests
+******************************************************************/
+
+func (cs *clientSuite) TestCheckForAddressee(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.unregisterCh = make(chan string, 5)
+	cli.StartAddresseeBatch()
+	calls := 0
+	cli.hasPackage = func(appId string) bool {
+		calls++
+		if appId == "app1" {
+			return false
+		}
+		return true
+	}
+	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: "app1"}), Equals, false)
+	c.Check(calls, Equals, 1)
+	c.Assert(cli.unregisterCh, HasLen, 1)
+	c.Check(<-cli.unregisterCh, Equals, "app1")
+	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: "app2"}), Equals, true)
+	c.Check(calls, Equals, 2)
+	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: "app1"}), Equals, false)
+	c.Check(calls, Equals, 2)
+	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: "app2"}), Equals, true)
+	c.Check(calls, Equals, 2)
+	c.Check(cli.unregisterCh, HasLen, 0)
+}
+
+/*****************************************************************
     deriveSessionConfig tests
 ******************************************************************/
 
@@ -273,10 +323,11 @@
 		ExchangeTimeout:        10 * time.Millisecond,
 		HostsCachingExpiryTime: 1 * time.Hour,
 		ExpectAllRepairedTime:  30 * time.Minute,
-		PEM:        cli.pem,
-		Info:       info,
-		AuthGetter: func(string) string { return "" },
-		AuthURL:    "xyzzy://",
+		PEM:              cli.pem,
+		Info:             info,
+		AuthGetter:       func(string) string { return "" },
+		AuthURL:          "xyzzy://",
+		AddresseeChecker: cli,
 	}
 	// sanity check that we are looking at all fields
 	vExpected := reflect.ValueOf(expected)
@@ -289,7 +340,7 @@
 	// finally compare
 	conf := cli.deriveSessionConfig(info)
 	// compare authGetter by string
-	c.Check(fmt.Sprintf("%v", conf.AuthGetter), Equals, fmt.Sprintf("%v", cli.getAuthorization))
+	c.Check(fmt.Sprintf("%#v", conf.AuthGetter), Equals, fmt.Sprintf("%#v", cli.getAuthorization))
 	// and set it to nil
 	conf.AuthGetter = nil
 	expected.AuthGetter = nil
@@ -297,6 +348,51 @@
 }
 
 /*****************************************************************
+    derivePushServiceSetup tests
+******************************************************************/
+
+func (cs *clientSuite) TestDerivePushServiceSetup(c *C) {
+	cs.writeTestConfig(map[string]interface{}{})
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	err := cli.configure()
+	c.Assert(err, IsNil)
+	cli.deviceId = "zoo"
+	expected := &service.PushServiceSetup{
+		DeviceId:   "zoo",
+		AuthGetter: func(string) string { return "" },
+		RegURL:     helpers.ParseURL("reg://"),
+	}
+	// sanity check that we are looking at all fields
+	vExpected := reflect.ValueOf(expected).Elem()
+	nf := vExpected.NumField()
+	for i := 0; i < nf; i++ {
+		fv := vExpected.Field(i)
+		// field isn't empty/zero
+		c.Assert(fv.Interface(), Not(DeepEquals), reflect.Zero(fv.Type()).Interface(), Commentf("forgot about: %s", vExpected.Type().Field(i).Name))
+	}
+	// finally compare
+	setup, err := cli.derivePushServiceSetup()
+	c.Assert(err, IsNil)
+	// compare authGetter by string
+	c.Check(fmt.Sprintf("%#v", setup.AuthGetter), Equals, fmt.Sprintf("%#v", cli.getAuthorization))
+	// and set it to nil
+	setup.AuthGetter = nil
+	expected.AuthGetter = nil
+	c.Check(setup, DeepEquals, expected)
+}
+
+func (cs *clientSuite) TestDerivePushServiceSetupError(c *C) {
+	cs.writeTestConfig(map[string]interface{}{
+		"registration_url": "%gh",
+	})
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	err := cli.configure()
+	c.Assert(err, IsNil)
+	_, err = cli.derivePushServiceSetup()
+	c.Check(err, ErrorMatches, "cannot parse registration url:.*")
+}
+
+/*****************************************************************
     startService tests
 ******************************************************************/
 
@@ -305,7 +401,8 @@
 		"auth_helper": helpers.ScriptAbsPath("dummyauth.sh"),
 	})
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.configure()
+	err := cli.configure()
+	c.Assert(err, IsNil)
 	cli.log = cs.log
 	cli.deviceId = "fake-id"
 	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
@@ -313,16 +410,26 @@
 	c.Check(cli.pushService, IsNil)
 	c.Check(cli.startService(), IsNil)
 	c.Assert(cli.pushService, NotNil)
-	c.Check(cli.pushService.IsRunning(), Equals, true)
-	c.Check(cli.pushService.GetDeviceId(), Equals, "fake-id")
-	c.Check(cli.pushService.GetRegistrationAuthorization(), Equals, "hello reg://")
+	pushService := cli.pushService.(*service.PushService)
+	c.Check(pushService.IsRunning(), Equals, true)
 	c.Assert(cli.setupPostalService(), IsNil)
 	c.Assert(cli.startPostalService(), IsNil)
 	c.Check(cli.postalService.IsRunning(), Equals, true)
-	cli.pushService.Stop()
+	pushService.Stop()
 	cli.postalService.Stop()
 }
 
+func (cs *clientSuite) TestStartServiceSetupError(c *C) {
+	cs.writeTestConfig(map[string]interface{}{
+		"registration_url": "%gh",
+	})
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	err := cli.configure()
+	c.Assert(err, IsNil)
+	err = cli.startService()
+	c.Check(err, ErrorMatches, "cannot parse registration url:.*")
+}
+
 func (cs *clientSuite) TestStartServiceErrorsOnNilLog(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	c.Check(cli.log, IsNil)
@@ -404,6 +511,10 @@
 	siCond := condition.Fail2Work(2)
 	siEndp := testibus.NewMultiValuedTestingEndpoint(siCond, condition.Work(true), []interface{}{int32(101), "mako", "daily", "Unknown", map[string]string{}})
 	testibus.SetWatchTicker(cEndp, make(chan bool))
+	ecCond := condition.Fail2Work(13)
+	ecEndp := testibus.NewTestingEndpoint(ecCond, condition.Work(true))
+	haCond := condition.Fail2Work(2)
+	haEndp := testibus.NewTestingEndpoint(haCond, condition.Work(true))
 	// ok, create the thing
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
@@ -418,6 +529,8 @@
 	cli.notificationsEndp = nEndp
 	cli.urlDispatcherEndp = uEndp
 	cli.connectivityEndp = cEndp
+	cli.emblemcounterEndp = ecEndp
+	cli.hapticEndp = haEndp
 	cli.systemImageEndp = siEndp
 
 	c.Assert(cli.takeTheBus(), IsNil)
@@ -434,6 +547,10 @@
 	c.Check(cCond.OK(), Equals, true)
 	// the systemimage endpoint retried until connected
 	c.Check(siCond.OK(), Equals, true)
+	// the emblemcounter endpoint retried until connected
+	c.Check(ecCond.OK(), Equals, true)
+	// the haptic endpoint retried until connected
+	c.Check(haCond.OK(), Equals, true)
 }
 
 // takeTheBus can, in fact, fail
@@ -449,6 +566,8 @@
 	cli.notificationsEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 	cli.urlDispatcherEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 	cli.connectivityEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
+	cli.emblemcounterEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
+	cli.hapticEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 	cli.systemImageEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 
 	c.Check(cli.takeTheBus(), NotNil)
@@ -654,7 +773,7 @@
 	args := testibus.GetCallArgs(endp)
 	c.Assert(args, HasLen, 1)
 	c.Check(args[0].Member, Equals, "Notify")
-	c.Check(cs.log.Captured(), Matches, `.* got notification id \d+\s*`)
+	c.Check(cs.log.Captured(), Matches, `(?s).* got notification id \d+\s*`)
 }
 
 func (cs *clientSuite) TestHandleBroadcastNotificationNothingToDo(c *C) {
@@ -686,18 +805,13 @@
 ******************************************************************/
 
 var payload = `{"message": "aGVsbG8=", "notification": {"card": {"icon": "icon-value", "summary": "summary-value", "body": "body-value", "actions": []}}}`
-var notif = &protocol.Notification{AppId: "hello", Payload: []byte(payload), MsgId: "42"}
+var notif = &protocol.Notification{AppId: "com.example.test_hello", Payload: []byte(payload), MsgId: "42"}
 
 func (cs *clientSuite) TestHandleUcastNotification(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	svcEndp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
 	postEndp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
 	cli.log = cs.log
-	cli.pushServiceEndpoint = svcEndp
 	cli.postalServiceEndpoint = postEndp
-	notsEndp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	cli.notificationsEndp = notsEndp
-	c.Assert(cli.startService(), IsNil)
 	c.Assert(cli.setupPostalService(), IsNil)
 	c.Assert(cli.startPostalService(), IsNil)
 	c.Check(cli.handleUnicastNotification(notif), IsNil)
@@ -705,13 +819,22 @@
 	args := testibus.GetCallArgs(postEndp)
 	c.Assert(len(args), Not(Equals), 0)
 	c.Check(args[len(args)-1].Member, Equals, "::Signal")
-	c.Check(cs.log.Captured(), Matches, `(?m).*sending notification "42" for "hello".*`)
+	c.Check(cs.log.Captured(), Matches, `(?m).*sending notification "42" for "com.example.test_hello".*`)
+}
+
+func (cs *clientSuite) TestHandleUcastFailsOnBadAppId(c *C) {
+	notif := &protocol.Notification{AppId: "bad-app-id", MsgId: "-1"}
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	c.Check(cli.handleUnicastNotification(notif), ErrorMatches, "invalid app id in notification")
 }
 
 /*****************************************************************
     handleClick tests
 ******************************************************************/
 
+var ACTION_ID_BROADCAST = service.ACTION_ID_PREFIX + service.SystemUpdateUrl + service.ACTION_ID_SUFFIX
+
 func (cs *clientSuite) TestHandleClick(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
@@ -723,14 +846,14 @@
 	args := testibus.GetCallArgs(endp)
 	c.Assert(args, HasLen, 0)
 	// check we worked with the right action id
-	c.Check(cli.handleClick(service.ACTION_ID_BROADCAST), IsNil)
+	c.Check(cli.handleClick(ACTION_ID_BROADCAST), IsNil)
 	// check we sent the notification
 	args = testibus.GetCallArgs(endp)
 	c.Assert(args, HasLen, 1)
 	c.Check(args[0].Member, Equals, "DispatchURL")
 	c.Check(args[0].Args, DeepEquals, []interface{}{service.SystemUpdateUrl})
 	// check we worked with the right action id
-	c.Check(cli.handleClick(service.ACTION_ID_SNOWFLAKE+"foo"), IsNil)
+	c.Check(cli.handleClick(service.ACTION_ID_PREFIX+"foo"), IsNil)
 	// check we sent the notification
 	args = testibus.GetCallArgs(endp)
 	c.Assert(args, HasLen, 2)
@@ -739,6 +862,64 @@
 }
 
 /*****************************************************************
+    handleUnregister tests
+******************************************************************/
+
+type testPushService struct {
+	err          error
+	unregistered string
+}
+
+func (ps *testPushService) Start() error {
+	return nil
+}
+
+func (ps *testPushService) Unregister(appId string) error {
+	ps.unregistered = appId
+	return ps.err
+}
+
+func (cs *clientSuite) TestHandleUnregister(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	cli.hasPackage = func(appId string) bool {
+		c.Check(appId, Equals, "app1")
+		return false
+	}
+	ps := &testPushService{}
+	cli.pushService = ps
+	cli.handleUnregister("app1")
+	c.Assert(ps.unregistered, Equals, "app1")
+	c.Check(cs.log.Captured(), Equals, "")
+}
+
+func (cs *clientSuite) TestHandleUnregisterNop(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	cli.hasPackage = func(appId string) bool {
+		c.Check(appId, Equals, "app1")
+		return true
+	}
+	ps := &testPushService{}
+	cli.pushService = ps
+	cli.handleUnregister("app1")
+	c.Assert(ps.unregistered, Equals, "")
+}
+
+func (cs *clientSuite) TestHandleUnregisterError(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	cli.hasPackage = func(appId string) bool {
+		return false
+	}
+	fail := errors.New("BAD")
+	ps := &testPushService{err: fail}
+	cli.pushService = ps
+	cli.handleUnregister("app1")
+	c.Check(cs.log.Captured(), Matches, "ERROR unregistering app1: BAD\n")
+}
+
+/*****************************************************************
     doLoop tests
 ******************************************************************/
 
@@ -747,6 +928,7 @@
 var nopBcast = func(*session.BroadcastNotification) error { return nil }
 var nopUcast = func(*protocol.Notification) error { return nil }
 var nopError = func(error) {}
+var nopUnregister = func(string) {}
 
 func (cs *clientSuite) TestDoLoopConn(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
@@ -757,7 +939,7 @@
 	c.Assert(cli.initSession(), IsNil)
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(func(bool) { ch <- true }, nopClick, nopBcast, nopUcast, nopError)
+	go cli.doLoop(func(bool) { ch <- true }, nopClick, nopBcast, nopUcast, nopError, nopUnregister)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -771,7 +953,7 @@
 	cli.actionsCh = aCh
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, func(_ string) error { ch <- true; return nil }, nopBcast, nopUcast, nopError)
+	go cli.doLoop(nopConn, func(_ string) error { ch <- true; return nil }, nopBcast, nopUcast, nopError, nopUnregister)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -784,7 +966,7 @@
 	cli.session.BroadcastCh <- &session.BroadcastNotification{}
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, nopClick, func(_ *session.BroadcastNotification) error { ch <- true; return nil }, nopUcast, nopError)
+	go cli.doLoop(nopConn, nopClick, func(_ *session.BroadcastNotification) error { ch <- true; return nil }, nopUcast, nopError, nopUnregister)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -797,7 +979,7 @@
 	cli.session.NotificationsCh <- &protocol.Notification{}
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, nopClick, nopBcast, func(*protocol.Notification) error { ch <- true; return nil }, nopError)
+	go cli.doLoop(nopConn, nopClick, nopBcast, func(*protocol.Notification) error { ch <- true; return nil }, nopError, nopUnregister)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -810,7 +992,20 @@
 	cli.session.ErrCh <- nil
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, nopClick, nopBcast, nopUcast, func(error) { ch <- true })
+	go cli.doLoop(nopConn, nopClick, nopBcast, nopUcast, func(error) { ch <- true }, nopUnregister)
+	c.Check(takeNextBool(ch), Equals, true)
+}
+
+func (cs *clientSuite) TestDoLoopUnregister(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	cli.systemImageInfo = siInfoRes
+	c.Assert(cli.initSession(), IsNil)
+	cli.unregisterCh = make(chan string, 1)
+	cli.unregisterCh <- "app1"
+
+	ch := make(chan bool, 1)
+	go cli.doLoop(nopConn, nopClick, nopBcast, nopUcast, nopError, func(appId string) { c.Check(appId, Equals, "app1"); ch <- true })
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -879,7 +1074,7 @@
 	c.Check(cs.log.Captured(), Matches, "(?ms).*Session connected after 42 attempts$")
 
 	//  * actionsCh to the click handler/url dispatcher
-	aCh <- notifications.RawActionReply{ActionId: service.ACTION_ID_BROADCAST}
+	aCh <- notifications.RawActionReply{ActionId: ACTION_ID_BROADCAST}
 	tick()
 	uargs := testibus.GetCallArgs(cli.urlDispatcherEndp)
 	c.Assert(uargs, HasLen, 1)
@@ -943,7 +1138,7 @@
 	// so we start,
 	err := cli.Start()
 	// and it works
-	c.Check(err, IsNil)
+	c.Assert(err, IsNil)
 
 	// and now everthing is better! We have a config,
 	c.Check(string(cli.config.Addr), Equals, ":0")
@@ -956,8 +1151,8 @@
 	// and a service,
 	c.Check(cli.pushService, NotNil)
 	// and everthying us just peachy!
-	cli.pushService.Stop()   // cleanup
-	cli.postalService.Stop() // cleanup
+	cli.pushService.(*service.PushService).Stop() // cleanup
+	cli.postalService.Stop()                      // cleanup
 }
 
 func (cs *clientSuite) TestStartCanFail(c *C) {
 
=== modified file 'client/service/common.go'
--- client/service/common.go	2014-07-01 11:55:30 +0000
+++ client/service/common.go	2014-07-07 14:23:18 +0000
@@ -20,10 +20,13 @@
 
 import (
 	"errors"
+	"strings"
 	"sync"
 
 	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/nih"
 )
 
 type DBusService struct {
@@ -43,10 +46,11 @@
 )
 
 var (
-	NotConfigured  = errors.New("not configured")
-	AlreadyStarted = errors.New("already started")
-	BadArgCount    = errors.New("Wrong number of arguments")
-	BadArgType     = errors.New("Bad argument type")
+	ErrNotConfigured  = errors.New("not configured")
+	ErrAlreadyStarted = errors.New("already started")
+	ErrBadArgCount    = errors.New("wrong number of arguments")
+	ErrBadArgType     = errors.New("bad argument type")
+	ErrBadAppId       = errors.New("package must be prefix of app id")
 )
 
 // IsRunning() returns whether the service's state is StateRunning
@@ -61,10 +65,10 @@
 	svc.lock.Lock()
 	defer svc.lock.Unlock()
 	if svc.state != StateUnknown {
-		return AlreadyStarted
+		return ErrAlreadyStarted
 	}
 	if svc.Log == nil || svc.Bus == nil {
-		return NotConfigured
+		return ErrNotConfigured
 	}
 	err := svc.Bus.Dial()
 	if err != nil {
@@ -97,3 +101,21 @@
 	}
 	svc.state = StateFinished
 }
+
+// grabDBusPackageAndAppId() extracts the appId from a dbus-provided
+// []interface{}, and checks it against the package in the last
+// element of the dbus path.
+func grabDBusPackageAndAppId(path string, args []interface{}, numExtra int) (pkgname string, appId string, err error) {
+	if len(args) != 1+numExtra {
+		return "", "", ErrBadArgCount
+	}
+	appId, ok := args[0].(string)
+	if !ok {
+		return "", "", ErrBadArgType
+	}
+	pkgname = string(nih.Unquote([]byte(path[strings.LastIndex(path, "/")+1:])))
+	if !click.AppInPackage(appId, pkgname) {
+		return "", "", ErrBadAppId
+	}
+	return
+}
 
=== added file 'client/service/common_test.go'
--- client/service/common_test.go	1970-01-01 00:00:00 +0000
+++ client/service/common_test.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,60 @@
+/*
+ Copyright 2014 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/>.
+*/
+
+package service
+
+import (
+	. "launchpad.net/gocheck"
+)
+
+type commonSuite struct{}
+
+var _ = Suite(&commonSuite{})
+
+func (cs *commonSuite) TestGrabDBusPackageAndAppIdWorks(c *C) {
+	aDBusPath := "/com/ubuntu/Postal/com_2eexample_2etest"
+	aPackage := "com.example.test"
+	anAppId := aPackage + "_test"
+	pkg, app, err := grabDBusPackageAndAppId(aDBusPath, []interface{}{anAppId}, 0)
+	c.Check(err, IsNil)
+	c.Check(pkg, Equals, aPackage)
+	c.Check(app, Equals, anAppId)
+}
+
+func (cs *commonSuite) TestGrabDBusPackageAndAppIdFails(c *C) {
+	aDBusPath := "/com/ubuntu/Postal/com_2eexample_2etest"
+	aPackage := "com.example.test"
+	anAppId := aPackage + "_test"
+
+	for i, s := range []struct {
+		path     string
+		args     []interface{}
+		numExtra int
+		errt     error
+	}{
+		{aDBusPath, []interface{}{}, 0, ErrBadArgCount},
+		{aDBusPath, []interface{}{anAppId}, 1, ErrBadArgCount},
+		{aDBusPath, []interface{}{anAppId, anAppId}, 0, ErrBadArgCount},
+		{aDBusPath, []interface{}{1}, 0, ErrBadArgType},
+		{aDBusPath, []interface{}{aPackage}, 0, ErrBadAppId},
+	} {
+		comment := Commentf("iteration #%d", i)
+		pkg, app, err := grabDBusPackageAndAppId(s.path, s.args, s.numExtra)
+		c.Check(err, Equals, s.errt, comment)
+		c.Check(pkg, Equals, "", comment)
+		c.Check(app, Equals, "", comment)
+	}
+}
 
=== modified file 'client/service/postal.go'
--- client/service/postal.go	2014-07-01 11:55:30 +0000
+++ client/service/postal.go	2014-07-07 14:23:18 +0000
@@ -17,17 +17,19 @@
 package service
 
 import (
-	"strings"
+	"sync"
 
 	"code.google.com/p/go-uuid/uuid"
-	"launchpad.net/go-dbus/v1"
 
 	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/bus/emblemcounter"
+	"launchpad.net/ubuntu-push/bus/haptic"
 	"launchpad.net/ubuntu-push/bus/notifications"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/messaging"
 	"launchpad.net/ubuntu-push/nih"
+	"launchpad.net/ubuntu-push/sounds"
 	"launchpad.net/ubuntu-push/util"
 )
 
@@ -38,6 +40,8 @@
 	msgHandler        func(string, string, *launch_helper.HelperOutput) error
 	HelperLauncher    launch_helper.HelperLauncher
 	messagingMenu     *messaging.MessagingMenu
+	emblemcounterEndp bus.Endpoint
+	hapticEndp        bus.Endpoint
 	notificationsEndp bus.Endpoint
 }
 
@@ -50,19 +54,21 @@
 )
 
 var (
-	SystemUpdateUrl     = "settings:///system/system-update"
-	ACTION_ID_SNOWFLAKE = "::ubuntu-push-client::"
-	ACTION_ID_BROADCAST = ACTION_ID_SNOWFLAKE + SystemUpdateUrl
+	SystemUpdateUrl  = "settings:///system/system-update"
+	ACTION_ID_PREFIX = "ubuntu-push-client::"
+	ACTION_ID_SUFFIX = "::0"
 )
 
 // NewPostalService() builds a new service and returns it.
-func NewPostalService(busEndp bus.Endpoint, notificationsEndp bus.Endpoint, log logger.Logger) *PostalService {
+func NewPostalService(busEndp bus.Endpoint, notificationsEndp bus.Endpoint, emblemcounterEndp bus.Endpoint, hapticEndp bus.Endpoint, log logger.Logger) *PostalService {
 	var svc = &PostalService{}
 	svc.Log = log
 	svc.Bus = busEndp
 	svc.messagingMenu = messaging.New(log)
 	svc.HelperLauncher = launch_helper.NewTrivialHelperLauncher(log)
 	svc.notificationsEndp = notificationsEndp
+	svc.emblemcounterEndp = emblemcounterEndp
+	svc.hapticEndp = hapticEndp
 	svc.msgHandler = svc.messageHandler
 	return svc
 }
@@ -84,24 +90,36 @@
 // Start() dials the bus, grab the name, and listens for method calls.
 func (svc *PostalService) Start() error {
 	return svc.DBusService.Start(bus.DispatchMap{
-		"Notifications": svc.notifications,
-		"Inject":        svc.inject,
+		"Messages": svc.notifications,
+		"Post":     svc.inject,
 	}, PostalServiceBusAddress)
 }
 
 func (svc *PostalService) TakeTheBus() (<-chan notifications.RawActionReply, error) {
-	iniCh := make(chan uint32)
-	go func() { iniCh <- util.NewAutoRedialer(svc.notificationsEndp).Redial() }()
-	<-iniCh
+	var wg sync.WaitGroup
+	endps := []bus.Endpoint{
+		svc.notificationsEndp,
+		svc.emblemcounterEndp,
+		svc.hapticEndp,
+	}
+	wg.Add(len(endps))
+	for _, endp := range endps {
+		go func(endp bus.Endpoint) {
+			util.NewAutoRedialer(endp).Redial()
+			wg.Done()
+		}(endp)
+	}
+	wg.Wait()
 	actionsCh, err := notifications.Raw(svc.notificationsEndp, svc.Log).WatchActions()
+
 	return actionsCh, err
 }
 
 func (svc *PostalService) notifications(path string, args, _ []interface{}) ([]interface{}, error) {
-	if len(args) != 0 {
-		return nil, BadArgCount
+	_, appId, err := grabDBusPackageAndAppId(path, args, 0)
+	if err != nil {
+		return nil, err
 	}
-	appname := string(nih.Unquote([]byte(path[strings.LastIndex(path, "/")+1:])))
 
 	svc.lock.Lock()
 	defer svc.lock.Unlock()
@@ -109,8 +127,8 @@
 	if svc.mbox == nil {
 		return []interface{}{[]string(nil)}, nil
 	}
-	msgs := svc.mbox[appname]
-	delete(svc.mbox, appname)
+	msgs := svc.mbox[appId]
+	delete(svc.mbox, appId)
 
 	return []interface{}{msgs}, nil
 }
@@ -118,23 +136,23 @@
 var newNid = uuid.New
 
 func (svc *PostalService) inject(path string, args, _ []interface{}) ([]interface{}, error) {
-	if len(args) != 1 {
-		return nil, BadArgCount
+	pkg, appId, err := grabDBusPackageAndAppId(path, args, 1)
+	if err != nil {
+		return nil, err
 	}
-	notif, ok := args[0].(string)
+	notif, ok := args[1].(string)
 	if !ok {
-		return nil, BadArgType
+		return nil, ErrBadArgType
 	}
-	appname := string(nih.Unquote([]byte(path[strings.LastIndex(path, "/")+1:])))
 
 	nid := newNid()
 
-	return nil, svc.Inject(appname, nid, notif)
+	return nil, svc.Inject(pkg, appId, nid, notif)
 }
 
 // Inject() signals to an application over dbus that a notification
 // has arrived.
-func (svc *PostalService) Inject(appname string, nid string, notif string) error {
+func (svc *PostalService) Inject(pkgname string, appname string, nid string, notif string) error {
 	svc.lock.Lock()
 	defer svc.lock.Unlock()
 	if svc.mbox == nil {
@@ -153,29 +171,28 @@
 		svc.DBusService.Log.Debugf("call to msgHandler successful")
 	}
 
-	return svc.Bus.Signal("Notification", "/"+string(nih.Quote([]byte(appname))), []interface{}{appname})
+	return svc.Bus.Signal("Post", "/"+string(nih.Quote([]byte(pkgname))), []interface{}{appname})
 }
 
 func (svc *PostalService) messageHandler(appname string, nid string, output *launch_helper.HelperOutput) error {
 	svc.messagingMenu.Present(appname, nid, output.Notification)
 	nots := notifications.Raw(svc.notificationsEndp, svc.Log)
 	_, err := nots.Present(appname, nid, output.Notification)
+	emblemcounter.New(svc.emblemcounterEndp, svc.Log).Present(appname, nid, output.Notification)
+	haptic.New(svc.hapticEndp, svc.Log).Present(appname, nid, output.Notification)
+	sounds.New(svc.Log).Present(appname, nid, output.Notification)
 
 	return err
 }
 
-func (svc *PostalService) SendNotification(action_id, icon, summary, body string) (uint32, error) {
-	a := []string{action_id, "Switch to app"} // action value not visible on the phone
-	h := map[string]*dbus.Variant{"x-canonical-switch-to-application": &dbus.Variant{true}}
-	nots := notifications.Raw(svc.notificationsEndp, svc.Log)
-	return nots.Notify(
-		"ubuntu-push-client", // app name
-		uint32(0),            // id
-		icon,                 // icon
-		summary,              // summary
-		body,                 // body
-		a,                    // actions
-		h,                    // hints
-		int32(10*1000),       // timeout (ms)
-	)
+func (svc *PostalService) InjectBroadcast() (uint32, error) {
+	// XXX: call a helper?
+	// XXX: Present force us to send the url as the notificationId
+	icon := "update_manager_icon"
+	summary := "There's an updated system image."
+	body := "Tap to open the system updater."
+	actions := []string{"Switch to app"} // action value not visible on the phone
+	card := &launch_helper.Card{Icon: icon, Summary: summary, Body: body, Actions: actions, Popup: true}
+	output := &launch_helper.HelperOutput{[]byte(""), &launch_helper.Notification{Card: card}}
+	return 0, svc.msgHandler("ubuntu-push-client", SystemUpdateUrl, output)
 }
 
=== modified file 'client/service/postal_test.go'
--- client/service/postal_test.go	2014-07-01 11:55:30 +0000
+++ client/service/postal_test.go	2014-07-07 14:23:18 +0000
@@ -18,6 +18,7 @@
 
 import (
 	"errors"
+	"sort"
 
 	. "launchpad.net/gocheck"
 
@@ -29,9 +30,11 @@
 )
 
 type postalSuite struct {
-	log      *helpers.TestLogger
-	bus      bus.Endpoint
-	notifBus bus.Endpoint
+	log        *helpers.TestLogger
+	bus        bus.Endpoint
+	notifBus   bus.Endpoint
+	counterBus bus.Endpoint
+	hapticBus  bus.Endpoint
 }
 
 var _ = Suite(&postalSuite{})
@@ -40,10 +43,12 @@
 	ss.log = helpers.NewTestLogger(c, "debug")
 	ss.bus = testibus.NewTestingEndpoint(condition.Work(true), nil)
 	ss.notifBus = testibus.NewTestingEndpoint(condition.Work(true), nil)
+	ss.counterBus = testibus.NewTestingEndpoint(condition.Work(true), nil)
+	ss.hapticBus = testibus.NewTestingEndpoint(condition.Work(true), nil)
 }
 
 func (ss *postalSuite) TestStart(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
 	c.Check(svc.IsRunning(), Equals, false)
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.IsRunning(), Equals, true)
@@ -51,45 +56,45 @@
 }
 
 func (ss *postalSuite) TestStartTwice(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
 	c.Check(svc.Start(), IsNil)
-	c.Check(svc.Start(), Equals, AlreadyStarted)
+	c.Check(svc.Start(), Equals, ErrAlreadyStarted)
 	svc.Stop()
 }
 
 func (ss *postalSuite) TestStartNoLog(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, nil)
-	c.Check(svc.Start(), Equals, NotConfigured)
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, nil)
+	c.Check(svc.Start(), Equals, ErrNotConfigured)
 }
 
 func (ss *postalSuite) TestStartNoBus(c *C) {
-	svc := NewPostalService(nil, ss.notifBus, ss.log)
-	c.Check(svc.Start(), Equals, NotConfigured)
+	svc := NewPostalService(nil, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
+	c.Check(svc.Start(), Equals, ErrNotConfigured)
 }
 
 func (ss *postalSuite) TestTakeTheBustFail(c *C) {
 	nEndp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), condition.Work(false), []interface{}{uint32(1), "hello"})
-	svc := NewPostalService(ss.bus, nEndp, ss.log)
+	svc := NewPostalService(ss.bus, nEndp, ss.counterBus, ss.hapticBus, ss.log)
 	_, err := svc.TakeTheBus()
 	c.Check(err, NotNil)
 }
 
 func (ss *postalSuite) TestTakeTheBustOk(c *C) {
 	nEndp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), condition.Work(true), []interface{}{uint32(1), "hello"})
-	svc := NewPostalService(ss.bus, nEndp, ss.log)
+	svc := NewPostalService(ss.bus, nEndp, ss.counterBus, ss.hapticBus, ss.log)
 	_, err := svc.TakeTheBus()
 	c.Check(err, IsNil)
 }
 
 func (ss *postalSuite) TestStartFailsOnBusDialFailure(c *C) {
 	bus := testibus.NewTestingEndpoint(condition.Work(false), nil)
-	svc := NewPostalService(bus, ss.notifBus, ss.log)
+	svc := NewPostalService(bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
 	c.Check(svc.Start(), ErrorMatches, `.*(?i)cond said no.*`)
 	svc.Stop()
 }
 
 func (ss *postalSuite) TestStartGrabsName(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
 	c.Assert(svc.Start(), IsNil)
 	callArgs := testibus.GetCallArgs(ss.bus)
 	defer svc.Stop()
@@ -98,7 +103,7 @@
 }
 
 func (ss *postalSuite) TestStopClosesBus(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
 	c.Assert(svc.Start(), IsNil)
 	svc.Stop()
 	callArgs := testibus.GetCallArgs(ss.bus)
@@ -110,31 +115,31 @@
 // Injection tests
 
 func (ss *postalSuite) TestInjectWorks(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
 	svc.msgHandler = nil
-	rvs, err := svc.inject("/hello", []interface{}{"world"}, nil)
+	rvs, err := svc.inject(aPackageOnBus, []interface{}{anAppId, "world"}, nil)
 	c.Assert(err, IsNil)
 	c.Check(rvs, IsNil)
-	rvs, err = svc.inject("/hello", []interface{}{"there"}, nil)
+	rvs, err = svc.inject(aPackageOnBus, []interface{}{anAppId, "there"}, nil)
 	c.Assert(err, IsNil)
 	c.Check(rvs, IsNil)
 	c.Assert(svc.mbox, HasLen, 1)
-	c.Assert(svc.mbox["hello"], HasLen, 2)
-	c.Check(svc.mbox["hello"][0], Equals, "world")
-	c.Check(svc.mbox["hello"][1], Equals, "there")
+	c.Assert(svc.mbox[anAppId], HasLen, 2)
+	c.Check(svc.mbox[anAppId][0], Equals, "world")
+	c.Check(svc.mbox[anAppId][1], Equals, "there")
 
 	// and check it fired the right signal (twice)
 	callArgs := testibus.GetCallArgs(ss.bus)
 	c.Assert(callArgs, HasLen, 2)
 	c.Check(callArgs[0].Member, Equals, "::Signal")
-	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"Notification", "/hello", []interface{}{"hello"}})
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"Post", aPackageOnBus, []interface{}{anAppId}})
 	c.Check(callArgs[1], DeepEquals, callArgs[0])
 }
 
 func (ss *postalSuite) TestInjectFailsIfInjectFails(c *C) {
 	bus := testibus.NewTestingEndpoint(condition.Work(true),
 		condition.Work(false))
-	svc := NewPostalService(bus, ss.notifBus, ss.log)
+	svc := NewPostalService(bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
 	svc.SetMessageHandler(func(string, string, *launch_helper.HelperOutput) error { return errors.New("fail") })
 	_, err := svc.inject("/hello", []interface{}{"xyzzy"}, nil)
 	c.Check(err, NotNil)
@@ -145,22 +150,57 @@
 		args []interface{}
 		errt error
 	}{
-		{nil, BadArgCount},
-		{[]interface{}{}, BadArgCount},
-		{[]interface{}{1}, BadArgType},
-		{[]interface{}{1, 2}, BadArgCount},
+		{nil, ErrBadArgCount},
+		{[]interface{}{}, ErrBadArgCount},
+		{[]interface{}{1}, ErrBadArgCount},
+		{[]interface{}{anAppId, 1}, ErrBadArgType},
+		{[]interface{}{1, "hello"}, ErrBadArgType},
+		{[]interface{}{1, 2, 3}, ErrBadArgCount},
+		{[]interface{}{"bar", "hello"}, ErrBadAppId},
 	} {
-		reg, err := new(PostalService).inject("", s.args, nil)
+		reg, err := new(PostalService).inject(aPackageOnBus, s.args, nil)
 		c.Check(reg, IsNil, Commentf("iteration #%d", i))
 		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
 	}
 }
 
 //
+// Injection (Broadcast) tests
+
+func (ss *postalSuite) TestInjectBroadcast(c *C) {
+	bus := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	svc := NewPostalService(ss.bus, bus, ss.counterBus, ss.hapticBus, ss.log)
+	//svc.msgHandler = nil
+	rvs, err := svc.InjectBroadcast()
+	c.Assert(err, IsNil)
+	c.Check(rvs, Equals, uint32(0))
+	c.Assert(err, IsNil)
+	// and check it fired the right signal (twice)
+	callArgs := testibus.GetCallArgs(bus)
+	c.Assert(callArgs, HasLen, 1)
+	c.Check(callArgs[0].Member, Equals, "Notify")
+	c.Check(callArgs[0].Args[0:6], DeepEquals, []interface{}{"ubuntu-push-client", uint32(0), "update_manager_icon",
+		"There's an updated system image.", "Tap to open the system updater.",
+		[]string{"ubuntu-push-client::settings:///system/system-update::0", "Switch to app"}})
+	// TODO: check the map in callArgs?
+	// c.Check(callArgs[0].Args[7]["x-canonical-secondary-icon"], NotNil)
+	// c.Check(callArgs[0].Args[7]["x-canonical-snap-decisions"], NotNil)
+}
+
+func (ss *postalSuite) TestInjectBroadcastFails(c *C) {
+	bus := testibus.NewTestingEndpoint(condition.Work(true),
+		condition.Work(false))
+	svc := NewPostalService(ss.bus, bus, ss.counterBus, ss.hapticBus, ss.log)
+	svc.SetMessageHandler(func(string, string, *launch_helper.HelperOutput) error { return errors.New("fail") })
+	_, err := svc.InjectBroadcast()
+	c.Check(err, NotNil)
+}
+
+//
 // Notifications tests
 func (ss *postalSuite) TestNotificationsWorks(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
-	nots, err := svc.notifications("/hello", nil, nil)
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
+	nots, err := svc.notifications(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Assert(err, IsNil)
 	c.Assert(nots, NotNil)
 	c.Assert(nots, HasLen, 1)
@@ -168,8 +208,8 @@
 	if svc.mbox == nil {
 		svc.mbox = make(map[string][]string)
 	}
-	svc.mbox["hello"] = append(svc.mbox["hello"], "this", "thing")
-	nots, err = svc.notifications("/hello", nil, nil)
+	svc.mbox[anAppId] = append(svc.mbox[anAppId], "this", "thing")
+	nots, err = svc.notifications(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Assert(err, IsNil)
 	c.Assert(nots, NotNil)
 	c.Assert(nots, HasLen, 1)
@@ -177,9 +217,19 @@
 }
 
 func (ss *postalSuite) TestNotificationsFailsIfBadArgs(c *C) {
-	reg, err := new(PostalService).notifications("/foo", []interface{}{1}, nil)
-	c.Check(reg, IsNil)
-	c.Check(err, Equals, BadArgCount)
+	for i, s := range []struct {
+		args []interface{}
+		errt error
+	}{
+		{nil, ErrBadArgCount},
+		{[]interface{}{}, ErrBadArgCount},
+		{[]interface{}{1}, ErrBadArgType},
+		{[]interface{}{"potato"}, ErrBadAppId},
+	} {
+		reg, err := new(PostalService).notifications(aPackageOnBus, s.args, nil)
+		c.Check(reg, IsNil, Commentf("iteration #%d", i))
+		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
+	}
 }
 
 func (ss *postalSuite) TestMessageHandlerPublicAPI(c *C) {
@@ -198,35 +248,44 @@
 
 func (ss *postalSuite) TestInjectCallsMessageHandler(c *C) {
 	var ext = &launch_helper.HelperOutput{}
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
 	f := func(app string, nid string, s *launch_helper.HelperOutput) error { ext = s; return nil }
 	svc.SetMessageHandler(f)
-	c.Check(svc.Inject("stuff", "thing", "{}"), IsNil)
+	c.Check(svc.Inject("pkg", "app", "thing", "{}"), IsNil)
 	c.Check(ext, DeepEquals, &launch_helper.HelperOutput{})
 	err := errors.New("ouch")
 	svc.SetMessageHandler(func(string, string, *launch_helper.HelperOutput) error { return err })
-	c.Check(svc.Inject("stuff", "", "{}"), Equals, err)
+	c.Check(svc.Inject("pkg", "app", "", "{}"), Equals, err)
 }
 
-func (ss *postalSuite) TestMessageHandler(c *C) {
+func (ss *postalSuite) TestMessageHandlerPresents(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	svc := NewPostalService(ss.bus, endp, ss.log)
-	card := &launch_helper.Card{Icon: "icon-value", Summary: "summary-value", Body: "body-value", Popup: true}
-	output := &launch_helper.HelperOutput{Notification: &launch_helper.Notification{Card: card}}
-	err := svc.messageHandler("xyzzy", "", output)
+	svc := NewPostalService(endp, endp, endp, endp, ss.log)
+	// Persist is false so we just check the log
+	card := &launch_helper.Card{Icon: "icon-value", Summary: "summary-value", Body: "body-value", Popup: true, Persist: false}
+	vib := &launch_helper.Vibration{Duration: 500}
+	emb := &launch_helper.EmblemCounter{Count: 2, Visible: true}
+	output := &launch_helper.HelperOutput{Notification: &launch_helper.Notification{Card: card, EmblemCounter: emb, Vibrate: vib}}
+	err := svc.messageHandler("com.example.test_test", "", output)
 	c.Assert(err, IsNil)
 	args := testibus.GetCallArgs(endp)
-	c.Assert(args, HasLen, 1)
-	c.Check(args[0].Member, Equals, "Notify")
-	c.Check(args[0].Args[0], Equals, "xyzzy")
-	c.Check(args[0].Args[2], Equals, "icon-value")
-	c.Check(args[0].Args[3], Equals, "summary-value")
-	c.Check(args[0].Args[4], Equals, "body-value")
+	c.Assert(args, HasLen, 4)
+	mm := make([]string, len(args))
+	for i, m := range args {
+		mm[i] = m.Member
+	}
+	sort.Strings(mm)
+	// check the Present() methods were called.
+	// For dbus-backed presenters, just check the right dbus methods are called
+	c.Check(mm, DeepEquals, []string{"::SetProperty", "::SetProperty", "Notify", "VibratePattern"})
+	// For the other ones, check the logs
+	c.Check(ss.log.Captured(), Matches, `(?sm).* no persistable card:.*`)
+	c.Check(ss.log.Captured(), Matches, `(?sm).* no Sound in the notification.*`)
 }
 
 func (ss *postalSuite) TestMessageHandlerReportsFailedNotifies(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
-	svc := NewPostalService(ss.bus, endp, ss.log)
+	svc := NewPostalService(ss.bus, endp, ss.counterBus, ss.hapticBus, ss.log)
 	card := &launch_helper.Card{Icon: "icon-value", Summary: "summary-value", Body: "body-value", Popup: true}
 	notif := &launch_helper.Notification{Card: card}
 	output := &launch_helper.HelperOutput{Notification: notif}
@@ -235,7 +294,7 @@
 }
 
 func (ss *postalSuite) TestMessageHandlerReportsButIgnoresUnmarshalErrors(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.log)
+	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
 	output := &launch_helper.HelperOutput{[]byte(`broken`), nil}
 	err := svc.messageHandler("", "", output)
 	c.Check(err, IsNil)
@@ -244,7 +303,7 @@
 
 func (ss *postalSuite) TestMessageHandlerReportsButIgnoresNilNotifies(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
-	svc := NewPostalService(ss.bus, endp, ss.log)
+	svc := NewPostalService(ss.bus, endp, ss.counterBus, ss.hapticBus, ss.log)
 	output := &launch_helper.HelperOutput{[]byte(`{}`), nil}
 	err := svc.messageHandler("", "", output)
 	c.Assert(err, IsNil)
 
=== modified file 'client/service/service.go'
--- client/service/service.go	2014-07-01 11:55:30 +0000
+++ client/service/service.go	2014-07-07 14:23:18 +0000
@@ -23,8 +23,8 @@
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"net/url"
 	"os"
-	"strings"
 
 	"launchpad.net/ubuntu-push/bus"
 	http13 "launchpad.net/ubuntu-push/http13client"
@@ -32,10 +32,17 @@
 	"launchpad.net/ubuntu-push/nih"
 )
 
+// PushServiceSetup encapsulates the params for setting up a PushService.
+type PushServiceSetup struct {
+	RegURL     *url.URL
+	DeviceId   string
+	AuthGetter func(string) string
+}
+
 // PushService is the dbus api
 type PushService struct {
 	DBusService
-	regURL     string
+	regURL     *url.URL
 	deviceId   string
 	authGetter func(string) string
 	httpCli    http13.Client
@@ -50,72 +57,42 @@
 )
 
 // NewPushService() builds a new service and returns it.
-func NewPushService(bus bus.Endpoint, log logger.Logger) *PushService {
+func NewPushService(bus bus.Endpoint, setup *PushServiceSetup, log logger.Logger) *PushService {
 	var svc = &PushService{}
 	svc.Log = log
 	svc.Bus = bus
+	svc.regURL = setup.RegURL
+	svc.deviceId = setup.DeviceId
+	svc.authGetter = setup.AuthGetter
 	return svc
 }
 
-// SetRegistrationURL() sets the registration url for the service
-func (svc *PushService) SetRegistrationURL(url string) {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	svc.regURL = url
-}
-
-// SetAuthGetter() sets the authorization getter for the service
-func (svc *PushService) SetAuthGetter(authGetter func(string) string) {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	svc.authGetter = authGetter
-}
-
-// getRegistrationAuthorization() returns the authorization header for
-// POSTing to the registration HTTP endpoint
-//
-// (this is for calling with the lock held)
-func (svc *PushService) getRegistrationAuthorization() string {
-	if svc.authGetter != nil && svc.regURL != "" {
-		return svc.authGetter(svc.regURL)
-	} else {
-		return ""
-	}
-}
-
-// GetRegistrationAuthorization() returns the authorization header for
-// POSTing to the registration HTTP endpoint
-func (svc *PushService) GetRegistrationAuthorization() string {
-	svc.lock.RLock()
-	defer svc.lock.RUnlock()
-	return svc.getRegistrationAuthorization()
-}
-
-// SetDeviceId() sets the device id
-func (svc *PushService) SetDeviceId(deviceId string) {
-	svc.lock.Lock()
-	defer svc.lock.Unlock()
-	svc.deviceId = deviceId
-}
-
-// GetDeviceId() returns the device id
-func (svc *PushService) GetDeviceId() string {
-	svc.lock.RLock()
-	defer svc.lock.RUnlock()
-	return svc.deviceId
+// getAuthorization() returns the URL and the authorization header for
+// POSTing to the registration HTTP endpoint for op
+func (svc *PushService) getAuthorization(op string) (string, string) {
+	if svc.authGetter == nil || svc.regURL == nil {
+		return "", ""
+	}
+	purl, err := svc.regURL.Parse(op)
+	if err != nil {
+		panic("op to getAuthorization was invalid")
+	}
+	url := purl.String()
+	return url, svc.authGetter(url)
 }
 
 func (svc *PushService) Start() error {
 	return svc.DBusService.Start(bus.DispatchMap{
-		"Register": svc.register,
+		"Register":   svc.register,
+		"Unregister": svc.unregister,
 	}, PushServiceBusAddress)
 }
 
 var (
-	BadServer  = errors.New("Bad server")
-	BadRequest = errors.New("Bad request")
-	BadToken   = errors.New("Bad token")
-	BadAuth    = errors.New("Bad auth")
+	ErrBadServer  = errors.New("bad server")
+	ErrBadRequest = errors.New("bad request")
+	ErrBadToken   = errors.New("bad token")
+	ErrBadAuth    = errors.New("bad auth")
 )
 
 type registrationRequest struct {
@@ -130,31 +107,20 @@
 	Message string `json:"message"` //
 }
 
-func (svc *PushService) register(path string, args, _ []interface{}) ([]interface{}, error) {
-	svc.lock.RLock()
-	defer svc.lock.RUnlock()
-	if len(args) != 0 {
-		return nil, BadArgCount
-	}
-	raw_appname := path[strings.LastIndex(path, "/")+1:]
-	appname := string(nih.Unquote([]byte(raw_appname)))
-
-	rv := os.Getenv("PUSH_REG_" + raw_appname)
-	if rv != "" {
-		return []interface{}{rv}, nil
-	}
-
-	req_body, err := json.Marshal(registrationRequest{svc.deviceId, appname})
+func (svc *PushService) manageReg(op, appId string) (*registrationReply, error) {
+	req_body, err := json.Marshal(registrationRequest{svc.deviceId, appId})
 	if err != nil {
 		return nil, fmt.Errorf("unable to marshal register request body: %v", err)
 	}
-	req, err := http13.NewRequest("POST", svc.regURL, bytes.NewReader(req_body))
-	if err != nil {
-		return nil, fmt.Errorf("unable to build register request: %v", err)
-	}
-	auth := svc.getRegistrationAuthorization()
+
+	url, auth := svc.getAuthorization(op)
 	if auth == "" {
-		return nil, BadAuth
+		return nil, ErrBadAuth
+	}
+
+	req, err := http13.NewRequest("POST", url, bytes.NewReader(req_body))
+	if err != nil {
+		panic(fmt.Errorf("unable to build register request: %v", err))
 	}
 	req.Header.Add("Authorization", auth)
 	req.Header.Add("Content-Type", "application/json")
@@ -169,9 +135,9 @@
 		switch {
 		case resp.StatusCode >= http.StatusInternalServerError:
 			// XXX retry on 503
-			return nil, BadServer
+			return nil, ErrBadServer
 		default:
-			return nil, BadRequest
+			return nil, ErrBadRequest
 		}
 	}
 	// errors below here Can't Happen (tm).
@@ -188,10 +154,44 @@
 		return nil, fmt.Errorf("unable to unmarshal register response: %v", err)
 	}
 
+	return &reply, nil
+}
+
+func (svc *PushService) register(path string, args, _ []interface{}) ([]interface{}, error) {
+	_, appId, err := grabDBusPackageAndAppId(path, args, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	rawAppId := string(nih.Quote([]byte(appId)))
+	rv := os.Getenv("PUSH_REG_" + rawAppId)
+	if rv != "" {
+		return []interface{}{rv}, nil
+	}
+
+	reply, err := svc.manageReg("/register", appId)
+	if err != nil {
+		return nil, err
+	}
+
 	if !reply.Ok || reply.Token == "" {
 		svc.Log.Errorf("Unexpected response: %#v", reply)
-		return nil, BadToken
+		return nil, ErrBadToken
 	}
 
 	return []interface{}{reply.Token}, nil
 }
+
+func (svc *PushService) unregister(path string, args, _ []interface{}) ([]interface{}, error) {
+	_, appId, err := grabDBusPackageAndAppId(path, args, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	return nil, svc.Unregister(appId)
+}
+
+func (svc *PushService) Unregister(appId string) error {
+	_, err := svc.manageReg("/unregister", appId)
+	return err
+}
 
=== modified file 'client/service/service_test.go'
--- client/service/service_test.go	2014-06-20 12:33:03 +0000
+++ client/service/service_test.go	2014-07-07 14:23:18 +0000
@@ -29,6 +29,7 @@
 	"launchpad.net/ubuntu-push/bus"
 	testibus "launchpad.net/ubuntu-push/bus/testing"
 	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/nih"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
 )
@@ -42,13 +43,36 @@
 
 var _ = Suite(&serviceSuite{})
 
+var (
+	aPackage      = "com.example.test"
+	anAppId       = aPackage + "_test-number-one"
+	aPackageOnBus = "/" + string(nih.Quote([]byte(aPackage)))
+)
+
 func (ss *serviceSuite) SetUpTest(c *C) {
 	ss.log = helpers.NewTestLogger(c, "debug")
 	ss.bus = testibus.NewTestingEndpoint(condition.Work(true), nil)
 }
 
+var testSetup = &PushServiceSetup{}
+
+func (ss *serviceSuite) TestBuild(c *C) {
+	setup := &PushServiceSetup{
+		RegURL:   helpers.ParseURL("http://reg"),
+		DeviceId: "FOO",
+		AuthGetter: func(s string) string {
+			return ""
+		},
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
+	c.Check(svc.Bus, Equals, ss.bus)
+	c.Check(svc.regURL, DeepEquals, helpers.ParseURL("http://reg"))
+	c.Check(fmt.Sprintf("%#v", svc.authGetter), Equals, fmt.Sprintf("%#v", setup.AuthGetter))
+	// ...
+}
+
 func (ss *serviceSuite) TestStart(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, testSetup, ss.log)
 	c.Check(svc.IsRunning(), Equals, false)
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.IsRunning(), Equals, true)
@@ -56,31 +80,31 @@
 }
 
 func (ss *serviceSuite) TestStartTwice(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, testSetup, ss.log)
 	c.Check(svc.Start(), IsNil)
-	c.Check(svc.Start(), Equals, AlreadyStarted)
+	c.Check(svc.Start(), Equals, ErrAlreadyStarted)
 	svc.Stop()
 }
 
 func (ss *serviceSuite) TestStartNoLog(c *C) {
-	svc := NewPushService(ss.bus, nil)
-	c.Check(svc.Start(), Equals, NotConfigured)
+	svc := NewPushService(ss.bus, testSetup, nil)
+	c.Check(svc.Start(), Equals, ErrNotConfigured)
 }
 
 func (ss *serviceSuite) TestStartNoBus(c *C) {
-	svc := NewPushService(nil, ss.log)
-	c.Check(svc.Start(), Equals, NotConfigured)
+	svc := NewPushService(nil, testSetup, ss.log)
+	c.Check(svc.Start(), Equals, ErrNotConfigured)
 }
 
 func (ss *serviceSuite) TestStartFailsOnBusDialFailure(c *C) {
 	bus := testibus.NewTestingEndpoint(condition.Work(false), nil)
-	svc := NewPushService(bus, ss.log)
+	svc := NewPushService(bus, testSetup, ss.log)
 	c.Check(svc.Start(), ErrorMatches, `.*(?i)cond said no.*`)
 	svc.Stop()
 }
 
 func (ss *serviceSuite) TestStartGrabsName(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, testSetup, ss.log)
 	c.Assert(svc.Start(), IsNil)
 	callArgs := testibus.GetCallArgs(ss.bus)
 	defer svc.Stop()
@@ -89,7 +113,7 @@
 }
 
 func (ss *serviceSuite) TestStopClosesBus(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
+	svc := NewPushService(ss.bus, testSetup, ss.log)
 	c.Assert(svc.Start(), IsNil)
 	svc.Stop()
 	callArgs := testibus.GetCallArgs(ss.bus)
@@ -99,41 +123,48 @@
 
 // registration tests
 
-func (ss *serviceSuite) TestSetRegURLWorks(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
-	c.Check(svc.regURL, Equals, "")
-	svc.SetRegistrationURL("xyzzy://")
-	c.Check(svc.regURL, Equals, "xyzzy://")
-}
-
-func (ss *serviceSuite) TestSetAuthGetterWorks(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
-	c.Check(svc.authGetter, IsNil)
-	f := func(string) string { return "" }
-	svc.SetAuthGetter(f)
-	c.Check(fmt.Sprintf("%#v", svc.authGetter), Equals, fmt.Sprintf("%#v", f))
-}
-
 func (ss *serviceSuite) TestGetRegAuthWorks(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
-	svc.SetRegistrationURL("xyzzy://")
 	ch := make(chan string, 1)
-	f := func(s string) string { ch <- s; return "Auth " + s }
-	svc.SetAuthGetter(f)
-	c.Check(svc.getRegistrationAuthorization(), Equals, "Auth xyzzy://")
+	setup := &PushServiceSetup{
+		RegURL: helpers.ParseURL("http://foo"),
+		AuthGetter: func(s string) string {
+			ch <- s
+			return "Auth " + s
+		},
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
+	url, auth := svc.getAuthorization("/op")
+	c.Check(auth, Equals, "Auth http://foo/op")
 	c.Assert(len(ch), Equals, 1)
-	c.Check(<-ch, Equals, "xyzzy://")
+	c.Check(<-ch, Equals, "http://foo/op")
+	c.Check(url, Equals, "http://foo/op")
 }
 
 func (ss *serviceSuite) TestGetRegAuthDoesNotPanic(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
-	c.Check(svc.getRegistrationAuthorization(), Equals, "")
+	svc := NewPushService(ss.bus, testSetup, ss.log)
+	_, auth := svc.getAuthorization("/op")
+	c.Check(auth, Equals, "")
 }
 
-func (ss *serviceSuite) TestRegistrationFailsIfBadArgs(c *C) {
-	reg, err := new(PushService).register("", []interface{}{1}, nil)
-	c.Check(reg, IsNil)
-	c.Check(err, Equals, BadArgCount)
+func (ss *serviceSuite) TestRegistrationAndUnregistrationFailIfBadArgs(c *C) {
+	for i, s := range []struct {
+		args []interface{}
+		errt error
+	}{
+		{nil, ErrBadArgCount},
+		{[]interface{}{}, ErrBadArgCount},
+		{[]interface{}{1}, ErrBadArgType},
+		{[]interface{}{"foo"}, ErrBadAppId},
+		{[]interface{}{"foo", "bar"}, ErrBadArgCount},
+	} {
+		reg, err := new(PushService).register("/bar", s.args, nil)
+		c.Check(reg, IsNil, Commentf("iteration #%d", i))
+		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
+
+		reg, err = new(PushService).unregister("/bar", s.args, nil)
+		c.Check(reg, IsNil, Commentf("iteration #%d", i))
+		c.Check(err, Equals, s.errt, Commentf("iteration #%d", i))
+	}
 }
 
 func (ss *serviceSuite) TestRegistrationWorks(c *C) {
@@ -143,19 +174,20 @@
 		c.Assert(e, IsNil)
 		req := registrationRequest{}
 		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
-		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", "an-app-id"})
-
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", anAppId})
+		c.Check(r.URL.Path, Equals, "/register")
 		w.Header().Set("Content-Type", "application/json")
 		fmt.Fprintln(w, `{"ok":true,"token":"blob-of-bytes"}`)
 	}))
 	defer ts.Close()
-
-	svc := NewPushService(ss.bus, ss.log)
-	svc.SetAuthGetter(func(string) string { return "tok" })
-	svc.SetRegistrationURL(ts.URL)
-	svc.SetDeviceId("fake-device-id")
+	setup := &PushServiceSetup{
+		DeviceId:   "fake-device-id",
+		RegURL:     helpers.ParseURL(ts.URL),
+		AuthGetter: func(string) string { return "tok" },
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
 	// this'll check (un)quoting, too
-	reg, err := svc.register("/an_2dapp_2did", nil, nil)
+	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Assert(err, IsNil)
 	c.Assert(reg, HasLen, 1)
 	regs, ok := reg[0].(string)
@@ -164,10 +196,11 @@
 }
 
 func (ss *serviceSuite) TestRegistrationOverrideWorks(c *C) {
-	os.Setenv("PUSH_REG_stuff", "42")
-	defer os.Setenv("PUSH_REG_stuff", "")
+	envar := "PUSH_REG_" + string(nih.Quote([]byte(anAppId)))
+	os.Setenv(envar, "42")
+	defer os.Setenv(envar, "")
 
-	reg, err := new(PushService).register("/stuff", nil, nil)
+	reg, err := new(PushService).register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Assert(reg, HasLen, 1)
 	regs, ok := reg[0].(string)
 	c.Check(ok, Equals, true)
@@ -175,103 +208,155 @@
 	c.Check(err, IsNil)
 }
 
-func (ss *serviceSuite) TestRegistrationFailsOnBadReqURL(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
-	svc.SetRegistrationURL("%gh")
-	reg, err := svc.register("thing", nil, nil)
-	c.Check(reg, IsNil)
-	c.Check(err, ErrorMatches, "unable to build register request: .*")
-}
-
-func (ss *serviceSuite) TestRegistrationFailsOnBadAuth(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
+func (ss *serviceSuite) TestManageRegFailsOnBadAuth(c *C) {
 	// ... no auth added
-	reg, err := svc.register("thing", nil, nil)
+	svc := NewPushService(ss.bus, testSetup, ss.log)
+	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(reg, IsNil)
-	c.Check(err, Equals, BadAuth)
+	c.Check(err, Equals, ErrBadAuth)
 }
 
-func (ss *serviceSuite) TestRegistrationFailsOnNoServer(c *C) {
-	svc := NewPushService(ss.bus, ss.log)
-	svc.SetRegistrationURL("xyzzy://")
-	svc.SetAuthGetter(func(string) string { return "tok" })
-	reg, err := svc.register("thing", nil, nil)
+func (ss *serviceSuite) TestManageRegFailsOnNoServer(c *C) {
+	setup := &PushServiceSetup{
+		DeviceId:   "fake-device-id",
+		RegURL:     helpers.ParseURL("xyzzy://"),
+		AuthGetter: func(string) string { return "tok" },
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
+	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(reg, IsNil)
 	c.Check(err, ErrorMatches, "unable to request registration: .*")
 }
 
-func (ss *serviceSuite) TestRegistrationFailsOn40x(c *C) {
+func (ss *serviceSuite) TestManageRegFailsOn40x(c *C) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "I'm a teapot", 418)
 	}))
 	defer ts.Close()
-
-	svc := NewPushService(ss.bus, ss.log)
-	svc.SetAuthGetter(func(string) string { return "tok" })
-	svc.SetRegistrationURL(ts.URL)
-	reg, err := svc.register("/thing", nil, nil)
-	c.Check(err, Equals, BadRequest)
+	setup := &PushServiceSetup{
+		DeviceId:   "fake-device-id",
+		RegURL:     helpers.ParseURL(ts.URL),
+		AuthGetter: func(string) string { return "tok" },
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
+	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
+	c.Check(err, Equals, ErrBadRequest)
 	c.Check(reg, IsNil)
 }
 
-func (ss *serviceSuite) TestRegistrationFailsOn50x(c *C) {
+func (ss *serviceSuite) TestManageRegFailsOn50x(c *C) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Not implemented", 501)
 	}))
 	defer ts.Close()
-
-	svc := NewPushService(ss.bus, ss.log)
-	svc.SetAuthGetter(func(string) string { return "tok" })
-	svc.SetRegistrationURL(ts.URL)
-	reg, err := svc.register("/thing", nil, nil)
-	c.Check(err, Equals, BadServer)
+	setup := &PushServiceSetup{
+		DeviceId:   "fake-device-id",
+		RegURL:     helpers.ParseURL(ts.URL),
+		AuthGetter: func(string) string { return "tok" },
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
+	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
+	c.Check(err, Equals, ErrBadServer)
 	c.Check(reg, IsNil)
 }
 
-func (ss *serviceSuite) TestRegistrationFailsOnBadJSON(c *C) {
+func (ss *serviceSuite) TestManageRegFailsOnBadJSON(c *C) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		buf := make([]byte, 256)
 		n, e := r.Body.Read(buf)
 		c.Assert(e, IsNil)
 		req := registrationRequest{}
 		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
-		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", "an-app-id"})
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", anAppId})
 
 		w.Header().Set("Content-Type", "application/json")
 		fmt.Fprintln(w, `{`)
 	}))
 	defer ts.Close()
-
-	svc := NewPushService(ss.bus, ss.log)
-	svc.SetAuthGetter(func(string) string { return "tok" })
-	svc.SetRegistrationURL(ts.URL)
-	svc.SetDeviceId("fake-device-id")
+	setup := &PushServiceSetup{
+		DeviceId:   "fake-device-id",
+		RegURL:     helpers.ParseURL(ts.URL),
+		AuthGetter: func(string) string { return "tok" },
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
 	// this'll check (un)quoting, too
-	reg, err := svc.register("/an_2dapp_2did", nil, nil)
+	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(reg, IsNil)
 	c.Check(err, ErrorMatches, "unable to unmarshal register response: .*")
 }
 
-func (ss *serviceSuite) TestRegistrationFailsOnBadJSONDocument(c *C) {
+func (ss *serviceSuite) TestManageRegFailsOnBadJSONDocument(c *C) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		buf := make([]byte, 256)
 		n, e := r.Body.Read(buf)
 		c.Assert(e, IsNil)
 		req := registrationRequest{}
 		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
-		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", "an-app-id"})
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", anAppId})
 
 		w.Header().Set("Content-Type", "application/json")
 		fmt.Fprintln(w, `{"bananas": "very yes"}`)
 	}))
 	defer ts.Close()
-
-	svc := NewPushService(ss.bus, ss.log)
-	svc.SetAuthGetter(func(string) string { return "tok" })
-	svc.SetRegistrationURL(ts.URL)
-	svc.SetDeviceId("fake-device-id")
+	setup := &PushServiceSetup{
+		DeviceId:   "fake-device-id",
+		RegURL:     helpers.ParseURL(ts.URL),
+		AuthGetter: func(string) string { return "tok" },
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
 	// this'll check (un)quoting, too
-	reg, err := svc.register("/an_2dapp_2did", nil, nil)
+	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(reg, IsNil)
-	c.Check(err, Equals, BadToken)
+	c.Check(err, Equals, ErrBadToken)
+}
+
+func (ss *serviceSuite) TestDBusUnregisterWorks(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 256)
+		n, e := r.Body.Read(buf)
+		c.Assert(e, IsNil)
+		req := registrationRequest{}
+		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", anAppId})
+		c.Check(r.URL.Path, Equals, "/unregister")
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{"ok":true,"token":"blob-of-bytes"}`)
+	}))
+	defer ts.Close()
+	setup := &PushServiceSetup{
+		DeviceId:   "fake-device-id",
+		RegURL:     helpers.ParseURL(ts.URL),
+		AuthGetter: func(string) string { return "tok" },
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
+	// this'll check (un)quoting, too
+	reg, err := svc.unregister(aPackageOnBus, []interface{}{anAppId}, nil)
+	c.Assert(err, IsNil)
+	c.Assert(reg, HasLen, 0)
+}
+
+func (ss *serviceSuite) TestUnregistrationWorks(c *C) {
+	invoked := make(chan bool, 1)
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 256)
+		n, e := r.Body.Read(buf)
+		c.Assert(e, IsNil)
+		req := registrationRequest{}
+		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
+		c.Check(req, DeepEquals, registrationRequest{"fake-device-id", anAppId})
+		c.Check(r.URL.Path, Equals, "/unregister")
+		invoked <- true
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprintln(w, `{"ok":true}`)
+	}))
+	defer ts.Close()
+	setup := &PushServiceSetup{
+		DeviceId:   "fake-device-id",
+		RegURL:     helpers.ParseURL(ts.URL),
+		AuthGetter: func(string) string { return "tok" },
+	}
+	svc := NewPushService(ss.bus, setup, ss.log)
+	err := svc.Unregister(anAppId)
+	c.Assert(err, IsNil)
+	c.Check(invoked, HasLen, 1)
 }
 
=== modified file 'client/session/session.go'
--- client/session/session.go	2014-06-13 12:19:26 +0000
+++ client/session/session.go	2014-07-07 14:23:18 +0000
@@ -78,6 +78,12 @@
 	Get() (*gethosts.Host, error)
 }
 
+// AddresseeChecking can check if a notification can be delivered.
+type AddresseeChecking interface {
+	StartAddresseeBatch()
+	CheckForAddressee(*protocol.Notification) bool
+}
+
 // ClientSessionConfig groups the client session configuration.
 type ClientSessionConfig struct {
 	ConnectTimeout         time.Duration
@@ -88,6 +94,7 @@
 	Info                   map[string]interface{}
 	AuthGetter             func(string) string
 	AuthURL                string
+	AddresseeChecker       AddresseeChecking
 }
 
 // ClientSession holds a client<->server session and its configuration.
@@ -426,8 +433,12 @@
 		return err
 	}
 	sess.clearShouldDelay()
+	sess.AddresseeChecker.StartAddresseeBatch()
 	for i := range notifs {
 		notif := &notifs[i]
+		if !sess.AddresseeChecker.CheckForAddressee(notif) {
+			continue
+		}
 		sess.Log.Debugf("unicast app:%v msg:%s payload:%s",
 			notif.AppId, notif.MsgId, notif.Payload)
 		sess.Log.Debugf("sending ucast over")
 
=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-06-13 12:19:26 +0000
+++ client/session/session_test.go	2014-07-07 14:23:18 +0000
@@ -798,7 +798,23 @@
   handleNotifications() tests
 ****************************************************************/
 
+type testAddresseeChecking struct {
+	ops     chan string
+	missing string
+}
+
+func (ac *testAddresseeChecking) StartAddresseeBatch() {
+	ac.ops <- "start"
+}
+
+func (ac *testAddresseeChecking) CheckForAddressee(notif *protocol.Notification) bool {
+	ac.ops <- notif.AppId
+	return notif.AppId != ac.missing
+}
+
 func (s *msgSuite) TestHandleNotificationsWorks(c *C) {
+	ac := &testAddresseeChecking{ops: make(chan string, 10)}
+	s.sess.AddresseeChecker = ac
 	s.sess.setShouldDelay()
 	n1 := protocol.Notification{
 		AppId:   "app1",
@@ -820,12 +836,52 @@
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, Equals, nil)
 	c.Check(s.sess.ShouldDelay(), Equals, false)
-	c.Assert(len(s.sess.NotificationsCh), Equals, 2)
+	c.Assert(s.sess.NotificationsCh, HasLen, 2)
 	c.Check(<-s.sess.NotificationsCh, DeepEquals, &n1)
 	c.Check(<-s.sess.NotificationsCh, DeepEquals, &n2)
+	c.Check(ac.ops, HasLen, 3)
+	c.Check(<-ac.ops, Equals, "start")
+	c.Check(<-ac.ops, Equals, "app1")
+	c.Check(<-ac.ops, Equals, "app2")
+}
+
+func (s *msgSuite) TestHandleNotificationsAddresseeCheck(c *C) {
+	ac := &testAddresseeChecking{
+		ops:     make(chan string, 10),
+		missing: "app1",
+	}
+	s.sess.AddresseeChecker = ac
+	s.sess.setShouldDelay()
+	n1 := protocol.Notification{
+		AppId:   "app1",
+		MsgId:   "a",
+		Payload: json.RawMessage(`{"m": 1}`),
+	}
+	n2 := protocol.Notification{
+		AppId:   "app2",
+		MsgId:   "b",
+		Payload: json.RawMessage(`{"m": 2}`),
+	}
+	msg := serverMsg{"notifications",
+		protocol.BroadcastMsg{},
+		protocol.NotificationsMsg{
+			Notifications: []protocol.Notification{n1, n2},
+		}, protocol.ConnBrokenMsg{}}
+	go func() { s.errCh <- s.sess.handleNotifications(&msg) }()
+	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
+	s.upCh <- nil // ack ok
+	c.Check(<-s.errCh, Equals, nil)
+	c.Check(s.sess.ShouldDelay(), Equals, false)
+	c.Assert(s.sess.NotificationsCh, HasLen, 1)
+	c.Check(<-s.sess.NotificationsCh, DeepEquals, &n2)
+	c.Check(ac.ops, HasLen, 3)
+	c.Check(<-ac.ops, Equals, "start")
+	c.Check(<-ac.ops, Equals, "app1")
 }
 
 func (s *msgSuite) TestHandleNotificationsFiltersSeen(c *C) {
+	ac := &testAddresseeChecking{ops: make(chan string, 10)}
+	s.sess.AddresseeChecker = ac
 	n1 := protocol.Notification{
 		AppId:   "app1",
 		MsgId:   "a",
@@ -845,16 +901,18 @@
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, Equals, nil)
-	c.Assert(len(s.sess.NotificationsCh), Equals, 2)
+	c.Assert(s.sess.NotificationsCh, HasLen, 2)
 	c.Check(<-s.sess.NotificationsCh, DeepEquals, &n1)
 	c.Check(<-s.sess.NotificationsCh, DeepEquals, &n2)
+	c.Check(ac.ops, HasLen, 3)
 
 	// second time they get ignored
 	go func() { s.errCh <- s.sess.handleNotifications(&msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, Equals, nil)
-	c.Assert(len(s.sess.NotificationsCh), Equals, 0)
+	c.Assert(s.sess.NotificationsCh, HasLen, 0)
+	c.Check(ac.ops, HasLen, 4)
 }
 
 func (s *msgSuite) TestHandleNotificationsBadAckWrite(c *C) {
 
=== modified file 'debian/changelog'
--- debian/changelog	2014-07-02 13:14:04 +0000
+++ debian/changelog	2014-07-07 14:23:18 +0000
@@ -1,3 +1,18 @@
+ubuntu-push (0.43) UNRELEASED; urgency=medium
+
+  [ Samuele Pedroni ]
+  * Logic to support unregistering tokens lazily for uninstalled apps
+  * Minimal wrapping of libclick to check if a package is installed for a user
+  * Refactor and cleanup of cleanup/service
+
+  [ John R. Lenton ]
+  * Finalized DBus API (hopefully)
+  * Support emblem counter notifications
+  * Support haptic (vibration) notifications
+  * Support sound notifications
+
+ -- John R. Lenton <[e-mail]>  Mon, 07 Jul 2014 15:22:42 +0100
+
 ubuntu-push (0.42+14.10.20140702-0ubuntu1) utopic; urgency=medium
 
   [ Samuele Pedroni ]
 
=== modified file 'debian/config.json'
--- debian/config.json	2014-06-19 21:12:04 +0000
+++ debian/config.json	2014-07-07 14:23:18 +0000
@@ -1,7 +1,7 @@
 {
     "auth_helper": "/usr/lib/ubuntu-push-client/signing-helper",
     "session_url": "https://push.ubuntu.com/",
-    "registration_url": "https://push.ubuntu.com/register",
+    "registration_url": "https://push.ubuntu.com",
     "connect_timeout": "20s",
     "exchange_timeout": "30s",
     "hosts_cache_expiry": "12h",
 
=== modified file 'debian/control'
--- debian/control	2014-06-23 13:29:39 +0000
+++ debian/control	2014-07-07 14:23:18 +0000
@@ -20,6 +20,7 @@
                libubuntuoneauth-2.0-dev,
                libdbus-1-dev,
                libnih-dbus-dev,
+               libclick-0.4-dev,
                cmake,
 Standards-Version: 3.9.5
 Homepage: http://launchpad.net/ubuntu-push
 
=== modified file 'launch_helper/helper_output.go'
--- launch_helper/helper_output.go	2014-06-30 12:19:14 +0000
+++ launch_helper/helper_output.go	2014-07-07 14:23:18 +0000
@@ -37,9 +37,9 @@
 // a Vibration generates a vibration in the form of a Pattern set in
 // duration a pattern of on off states, repeated a number of times
 type Vibration struct {
-	Duration uint     `json:"duration"` // if Duration is present and not 0, it's like a Pattern of [Duration] and a Repeat of 1; otherwise, Pattern and Repeat are used.
+	Duration uint32   `json:"duration"` // if Duration is present and not 0, it's like a Pattern of [Duration]; otherwise, Pattern is used.
 	Pattern  []uint32 `json:"pattern"`
-	Repeat   uint32   `json:"repeat"`
+	Repeat   uint32   `json:"repeat"` // defaults to 1. A value of zero is ignored (so it's like 1).
 }
 
 // a Notification can be any of the above
 
=== modified file 'messaging/messaging.go'
--- messaging/messaging.go	2014-07-01 00:51:59 +0000
+++ messaging/messaging.go	2014-07-07 14:23:18 +0000
@@ -43,6 +43,7 @@
 
 func (mmu *MessagingMenu) Present(appId string, notificationId string, notification *launch_helper.Notification) {
 	if notification == nil || notification.Card == nil || !notification.Card.Persist || notification.Card.Summary == "" {
+		mmu.Log.Debugf("[%s] no notification or notification has no persistable card: %#v", notificationId, notification)
 		return
 	}
 
 
=== modified file 'messaging/messaging_test.go'
--- messaging/messaging_test.go	2014-07-01 00:51:59 +0000
+++ messaging/messaging_test.go	2014-07-07 14:23:18 +0000
@@ -61,7 +61,7 @@
 
 	mmu.Present("app-id", "notif-id", &notif)
 
-	c.Check(ms.log.Captured(), Equals, "")
+	c.Check(ms.log.Captured(), Matches, "(?sm).*has no persistable card.*")
 }
 
 func (ms *MessagingSuite) TestPresentDoesNotPresentsIfNotPersist(c *C) {
@@ -71,17 +71,17 @@
 
 	mmu.Present("app-id", "notif-id", &notif)
 
-	c.Check(ms.log.Captured(), Equals, "")
+	c.Check(ms.log.Captured(), Matches, "(?sm).*has no persistable card.*")
 }
 
 func (ms *MessagingSuite) TestPresentDoesNotPresentsIfNil(c *C) {
 	mmu := New(ms.log)
 	mmu.Present("app-id", "notif-id", nil)
-	c.Check(ms.log.Captured(), Equals, "")
+	c.Check(ms.log.Captured(), Matches, "(?sm).*no notification.*")
 }
 
 func (ms *MessagingSuite) TestPresentDoesNotPresentsIfNilCard(c *C) {
 	mmu := New(ms.log)
 	mmu.Present("app-id", "notif-id", &launch_helper.Notification{})
-	c.Check(ms.log.Captured(), Equals, "")
+	c.Check(ms.log.Captured(), Matches, "(?sm).*no notification.*")
 }
 
=== modified file 'server/session/session_test.go'
--- server/session/session_test.go	2014-06-19 13:06:52 +0000
+++ server/session/session_test.go	2014-07-07 14:23:18 +0000
@@ -373,6 +373,7 @@
 		pingTimer:     time.NewTimer(pingInterval),
 		intervalStart: now,
 	}
+	time.Sleep(10 * time.Millisecond)
 	l.pingTimer.Stop()
 	done := l.pingTimerReset(true)
 	c.Assert(done, Equals, true)
 
=== added directory 'sounds'
=== added file 'sounds/sounds.go'
--- sounds/sounds.go	1970-01-01 00:00:00 +0000
+++ sounds/sounds.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,91 @@
+/*
+ Copyright 2014 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/>.
+*/
+
+package sounds
+
+import (
+	"os"
+	"os/exec"
+	"path"
+
+	"launchpad.net/go-xdg/v0"
+
+	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/launch_helper"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+type Sound struct {
+	player   string
+	log      logger.Logger
+	dataDirs func() []string
+	dataFind func(string) (string, error)
+}
+
+func New(log logger.Logger) *Sound {
+	return &Sound{player: "paplay", log: log, dataDirs: xdg.Data.Dirs, dataFind: xdg.Data.Find}
+}
+
+func (snd *Sound) Present(appId string, nid string, notification *launch_helper.Notification) bool {
+	if notification == nil || notification.Sound == "" {
+		snd.log.Debugf("[%s] no notification or no Sound in the notification; doing nothing: %#v", nid, notification)
+		return false
+	}
+	absPath := snd.findSoundFile(appId, nid, notification.Sound)
+	if absPath == "" {
+		snd.log.Debugf("[%s] unable to find sound %s", nid, notification.Sound)
+		return false
+	}
+	snd.log.Debugf("[%s] playing sound %s using %s", nid, absPath, snd.player)
+	cmd := exec.Command(snd.player, absPath)
+	err := cmd.Start()
+	if err != nil {
+		snd.log.Debugf("[%s] unable to play: %v", nid, err)
+		return false
+	}
+	go func() {
+		err := cmd.Wait()
+		if err != nil {
+			snd.log.Debugf("[%s] error playing sound %s: %v", nid, absPath, err)
+		}
+	}()
+	return true
+}
+
+func (snd *Sound) findSoundFile(appId string, nid string, sound string) string {
+	parsed, err := click.ParseAppId(appId)
+	if err != nil {
+		snd.log.Debugf("[%s] no appId in %#v", nid, appId)
+		return ""
+	}
+	// XXX also support legacy appIds?
+	// first, check package-specific
+	absPath, err := snd.dataFind(path.Join(parsed.Package, sound))
+	if err == nil {
+		// ffffound
+		return absPath
+	}
+	// next, check the XDG data dirs (but skip the first one -- that's "home")
+	// XXX should we only check in $XDG/sounds ? (that's for sound *themes*...)
+	for _, dir := range snd.dataDirs()[1:] {
+		absPath := path.Join(dir, sound)
+		_, err := os.Stat(absPath)
+		if err == nil {
+			return absPath
+		}
+	}
+	return ""
+}
 
=== added file 'sounds/sounds_test.go'
--- sounds/sounds_test.go	1970-01-01 00:00:00 +0000
+++ sounds/sounds_test.go	2014-07-07 14:23:18 +0000
@@ -0,0 +1,85 @@
+/*
+ Copyright 2014 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/>.
+*/
+
+package sounds
+
+import (
+	"errors"
+	"os"
+	"path"
+	"testing"
+
+	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/launch_helper"
+	helpers "launchpad.net/ubuntu-push/testing"
+)
+
+func TestSounds(t *testing.T) { TestingT(t) }
+
+type soundsSuite struct {
+	log *helpers.TestLogger
+}
+
+var _ = Suite(&soundsSuite{})
+
+func (ss *soundsSuite) SetUpTest(c *C) {
+	ss.log = helpers.NewTestLogger(c, "debug")
+}
+
+func (ss *soundsSuite) TestNew(c *C) {
+	s := New(ss.log)
+	c.Check(s.log, Equals, ss.log)
+	c.Check(s.player, Equals, "paplay")
+}
+
+func (ss *soundsSuite) TestPresent(c *C) {
+	s := &Sound{
+		player: "echo", log: ss.log,
+		dataFind: func(s string) (string, error) { return s, nil },
+	}
+
+	c.Check(s.Present("com.example.test_test", "",
+		&launch_helper.Notification{Sound: "hello"}), Equals, true)
+	c.Check(ss.log.Captured(), Matches, `(?sm).* playing sound com.example.test/hello using echo`)
+}
+
+func (ss *soundsSuite) TestPresentFails(c *C) {
+	s := &Sound{player: "/", log: ss.log}
+
+	// nil notification
+	c.Check(s.Present("", "", nil), Equals, false)
+	// no Sound
+	c.Check(s.Present("", "", &launch_helper.Notification{}), Equals, false)
+	// bad player
+	c.Check(s.Present("", "", &launch_helper.Notification{Sound: "hello"}), Equals, false)
+	s.player = "echo"
+	// bad app id
+	c.Check(s.Present("", "", &launch_helper.Notification{Sound: "hello"}), Equals, false)
+	s.dataFind = func(string) (string, error) { return "", errors.New("nope") }
+	s.dataDirs = func() []string { return []string{""} }
+	// no file found
+	c.Check(s.Present("com.example.test_test", "", &launch_helper.Notification{Sound: "hello"}), Equals, false)
+
+	// and now, just to prove it would've worked,
+
+	d := c.MkDir()
+	f, err := os.Create(path.Join(d, "hello"))
+	c.Assert(err, IsNil)
+	f.Close()
+	s.dataDirs = func() []string { return []string{"", d} }
+	c.Check(s.Present("com.example.test_test", "", &launch_helper.Notification{Sound: "hello"}), Equals, true)
+}
 
=== modified file 'testing/helpers.go'
--- testing/helpers.go	2014-06-23 12:46:28 +0000
+++ testing/helpers.go	2014-07-07 14:23:18 +0000
@@ -20,6 +20,7 @@
 import (
 	"encoding/json"
 	"fmt"
+	"net/url"
 	"os"
 	"path"
 	"path/filepath"
@@ -160,3 +161,12 @@
 	}
 	return res
 }
+
+// ParseURL parses a URL conveniently.
+func ParseURL(s string) *url.URL {
+	purl, err := url.Parse(s)
+	if err != nil {
+		panic(err)
+	}
+	return purl
+}
 
=== modified file 'whoopsie/identifier/identifier.go'
--- whoopsie/identifier/identifier.go	2014-06-13 12:23:03 +0000
+++ whoopsie/identifier/identifier.go	2014-07-07 14:23:18 +0000
@@ -62,6 +62,7 @@
 		if gerr == nil && cs != nil {
 			goto Success
 		}
+		C.g_clear_error(&gerr)
 		time.Sleep(600 * time.Millisecond)
 	}
 	return errors.New("whoopsie_identifier_generate still bad after 2m; giving up")