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

[John Lenton]

  [Samuele Pedroni]
  * Check in the api whether an app has pushed too many notifications.
  * Return payload of most recent notification in too many pending
    notifications API error.
  * Introduce clear_pending flag to clean everything pending for an app.
  * Refactor and cleanup.
  * Introduce replace_tag support in store and api, with acceptance test.
  * Teach a couple of trick to cmd/acceptanceclient: exit on run timeout,
    wait for event matching given regexp pattern.
  * Limit unicast data payload to 2K.
  * Payload should be json (fixes message needing to be base64-encoded in
    helper reply)
  * Implement limited mboxes
  * Refactor and cleanup of things done in haste by Chipaca.

  [Richard Huddie]
  * autopilot test framework and basic coverage of broadcast notifications.

  [Guillermo Gonzalez]
  * Add scripts to simplify setup/run of the autopilot tests in the
    device/emulator and include basic unicast tests.
  * Add autopilot test for notification using the emblem counter.
  * Adds scenarios to the autopilot tests for legacy and click (without
    version) applications.
  * Broadcast via the helpers route.
  * Basic support for actions (only default action) in the persistent
    notifications.
  * Change PostBroadcast to send the broadcast message to the software
    updates helper.

  [John R. Lenton]
  * Detangle client and postal.
  * Introduce PostalService interface, and change the client tests to use
    that as much as reasonable.
  * Async invocation of helpers.
  * Give click.Click knowledge of helpers.
  * Write ual-based helper launcher.
  * Switch to the ual-based helper launcher unless the environment
    variable UBUNTU_PUSH_USE_TRIVIAL_HELPER is set.
  * Threw together an implementation of helpers for legacy applications.
  * Hacked up an initial software updates helper, to be handed off to the
    appropriate team shortly.

  [Roberto Alsina]
  * Wrap the (dbus) WindowStack API and add endpoint to the Postal service
    to support inhibition of notifications for focused apps.
  * Inhibit notifications for focused apps

Merged from automatic.

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

109. By Richard Huddie on 2014-07-21

  [Samuele Pedroni]
  * Check in the api whether an app has pushed too many notifications.
  * Return payload of most recent notification in too many pending
    notifications API error.
  * Introduce clear_pending flag to clean everything pending for an app.
  * Refactor and cleanup.
  * Introduce replace_tag support in store and api, with acceptance test.
  * Teach a couple of trick to cmd/acceptanceclient: exit on run timeout,
    wait for event matching given regexp pattern.
  * Limit unicast data payload to 2K.
  * Payload should be json (fixes message needing to be base64-encoded in
    helper reply)
  * Implement limited mboxes
  * Refactor and cleanup of things done in haste by Chipaca.

  [Richard Huddie]
  * autopilot test framework and basic coverage of broadcast notifications.

  [Guillermo Gonzalez]
  * Add scripts to simplify setup/run of the autopilot tests in the
    device/emulator and include basic unicast tests.
  * Add autopilot test for notification using the emblem counter.
  * Adds scenarios to the autopilot tests for legacy and click (without
    version) applications.
  * Broadcast via the helpers route.
  * Basic support for actions (only default action) in the persistent
    notifications.
  * Change PostBroadcast to send the broadcast message to the software
    updates helper.

  [John R. Lenton]
  * Detangle client and postal.
  * Introduce PostalService interface, and change the client tests to use
    that as much as reasonable.
  * Async invocation of helpers.
  * Give click.Click knowledge of helpers.
  * Write ual-based helper launcher.
  * Switch to the ual-based helper launcher unless the environment
    variable UBUNTU_PUSH_USE_TRIVIAL_HELPER is set.
  * Threw together an implementation of helpers for legacy applications.
  * Hacked up an initial software updates helper, to be handed off to the
    appropriate team shortly.

  [Roberto Alsina]
  * Wrap the (dbus) WindowStack API and add endpoint to the Postal service
    to support inhibition of notifications for focused apps.
  * Inhibit notifications for focused apps

=== modified file 'bus/emblemcounter/emblemcounter.go'
--- bus/emblemcounter/emblemcounter.go	2014-07-06 19:57:47 +0000
+++ bus/emblemcounter/emblemcounter.go	2014-07-21 14:14:04 +0000
@@ -49,20 +49,15 @@
 
 // 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) {
+func (ctr *EmblemCounter) Present(app *click.AppId, nid 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)
+		ctr.log.Debugf("[%s] no notification or no EmblemCounter in the notification; doing nothing: %#v", nid, notification)
 		return
 	}
 	ec := notification.EmblemCounter
-	ctr.log.Debugf("setting emblem counter for %s to %d (visible: %t)", appId, ec.Count, ec.Visible)
+	ctr.log.Debugf("[%s] setting emblem counter for %s to %d (visible: %t)", nid, app.Base(), ec.Count, ec.Visible)
 
-	quoted := string(nih.Quote([]byte(parsed.Application)))
+	quoted := string(nih.Quote([]byte(app.Base())))
 
 	ctr.bus.SetProperty("count", "/"+quoted, dbus.Variant{ec.Count})
 	ctr.bus.SetProperty("countVisible", "/"+quoted, dbus.Variant{ec.Visible})

=== modified file 'bus/emblemcounter/emblemcounter_test.go'
--- bus/emblemcounter/emblemcounter_test.go	2014-07-06 19:57:47 +0000
+++ bus/emblemcounter/emblemcounter_test.go	2014-07-21 14:14:04 +0000
@@ -23,7 +23,10 @@
 	. "launchpad.net/gocheck"
 
 	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/click"
+	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	"launchpad.net/ubuntu-push/launch_helper"
+	"launchpad.net/ubuntu-push/nih"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
 )
@@ -32,48 +35,52 @@
 
 type ecSuite struct {
 	log *helpers.TestLogger
+	app *click.AppId
 }
 
 var _ = Suite(&ecSuite{})
 
 func (ecs *ecSuite) SetUpTest(c *C) {
 	ecs.log = helpers.NewTestLogger(c, "debug")
+	ecs.app = clickhelp.MustParseAppId("com.example.test_test-app_0")
 }
 
 // checks that Present() actually calls SetProperty on the launcher
 func (ecs *ecSuite) TestPresentPresents(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+	quoted := string(nih.Quote([]byte(ecs.app.Base())))
 
 	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)
+	ec.Present(ecs.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}})
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"count", "/" + quoted, dbus.Variant{Value: int32(42)}})
+	c.Check(callArgs[1].Args, DeepEquals, []interface{}{"countVisible", "/" + quoted, dbus.Variant{Value: true}})
 }
 
 // check that Present() doesn't call SetProperty if no EmblemCounter in the Notification
 func (ecs *ecSuite) TestSkipIfMissing(c *C) {
+	quoted := string(nih.Quote([]byte(ecs.app.Base())))
 	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)
+	ec.Present(ecs.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{})
+	ec.Present(ecs.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{}})
+	ec.Present(ecs.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}})
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}{"count", "/" + quoted, dbus.Variant{Value: int32(0)}})
+	c.Check(callArgs[1].Args, DeepEquals, []interface{}{"countVisible", "/" + quoted, dbus.Variant{Value: false}})
 }

=== modified file 'bus/haptic/haptic.go'
--- bus/haptic/haptic.go	2014-07-06 20:11:07 +0000
+++ bus/haptic/haptic.go	2014-07-21 14:14:04 +0000
@@ -20,6 +20,7 @@
 
 import (
 	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 )
@@ -43,7 +44,7 @@
 }
 
 // Present presents the notification via a vibrate pattern
-func (haptic *Haptic) Present(_, _ string, notification *launch_helper.Notification) bool {
+func (haptic *Haptic) Present(_ *click.AppId, _ 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
@@ -63,7 +64,7 @@
 	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)
+		haptic.log.Errorf("VibratePattern call returned %v", err)
 		return false
 	}
 	return true

=== modified file 'bus/haptic/haptic_test.go'
--- bus/haptic/haptic_test.go	2014-07-06 13:53:42 +0000
+++ bus/haptic/haptic_test.go	2014-07-21 14:14:04 +0000
@@ -22,6 +22,8 @@
 	. "launchpad.net/gocheck"
 
 	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/click"
+	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	"launchpad.net/ubuntu-push/launch_helper"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
@@ -31,12 +33,14 @@
 
 type hapticSuite struct {
 	log *helpers.TestLogger
+	app *click.AppId
 }
 
 var _ = Suite(&hapticSuite{})
 
 func (hs *hapticSuite) SetUpTest(c *C) {
 	hs.log = helpers.NewTestLogger(c, "debug")
+	hs.app = clickhelp.MustParseAppId("com.example.test_test-app_0")
 }
 
 // checks that Present() actually calls VibratePattern
@@ -45,7 +49,7 @@
 
 	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)
+	c.Check(ec.Present(hs.app, "nid", &notif), Equals, true)
 	callArgs := testibus.GetCallArgs(endp)
 	c.Assert(callArgs, HasLen, 1)
 	c.Check(callArgs[0].Member, Equals, "VibratePattern")
@@ -59,7 +63,7 @@
 	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)
+	c.Check(ec.Present(hs.app, "nid", &notif), Equals, true)
 	callArgs := testibus.GetCallArgs(endp)
 	c.Assert(callArgs, HasLen, 1)
 	c.Check(callArgs[0].Member, Equals, "VibratePattern")
@@ -74,7 +78,7 @@
 	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)
+	c.Check(ec.Present(hs.app, "nid", &notif), Equals, true)
 	callArgs := testibus.GetCallArgs(endp)
 	c.Assert(callArgs, HasLen, 1)
 	c.Check(callArgs[0].Member, Equals, "VibratePattern")
@@ -89,7 +93,7 @@
 	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)
+	c.Check(ec.Present(hs.app, "nid", &notif), Equals, true)
 	callArgs := testibus.GetCallArgs(endp)
 	c.Assert(callArgs, HasLen, 1)
 	c.Check(callArgs[0].Member, Equals, "VibratePattern")
@@ -103,9 +107,9 @@
 
 	ec := New(endp, hs.log)
 	// no notification at all
-	c.Check(ec.Present("", "", nil), Equals, false)
+	c.Check(ec.Present(hs.app, "", nil), Equals, false)
 	// no Vibration in the notificaton
-	c.Check(ec.Present("", "", &launch_helper.Notification{}), Equals, false)
+	c.Check(ec.Present(hs.app, "", &launch_helper.Notification{}), Equals, false)
 	// empty Vibration
-	c.Check(ec.Present("", "", &launch_helper.Notification{Vibrate: &launch_helper.Vibration{}}), Equals, false)
+	c.Check(ec.Present(hs.app, "", &launch_helper.Notification{Vibrate: &launch_helper.Vibration{}}), Equals, false)
 }

=== modified file 'bus/notifications/raw.go'
--- bus/notifications/raw.go	2014-07-01 11:55:30 +0000
+++ bus/notifications/raw.go	2014-07-21 14:14:04 +0000
@@ -22,12 +22,13 @@
 // this is the lower-level api
 
 import (
+	"encoding/json"
 	"errors"
-	"fmt"
 
 	"launchpad.net/go-dbus/v1"
+
 	"launchpad.net/ubuntu-push/bus"
-	c_helper "launchpad.net/ubuntu-push/bus/notifications/app_helper"
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 )
@@ -44,9 +45,12 @@
  */
 
 // convenience type for the (uint32, string) ActionInvoked signal data
-type RawActionReply struct {
-	NotificationId uint32
-	ActionId       string
+type RawAction struct {
+	App      *click.AppId `json:"app,omitempty"`
+	Action   string       `json:"act,omitempty"`
+	ActionId int          `json:"aid,omitempty"`
+	Nid      string       `json:"nid,omitempty"`
+	RawId    uint32       `json:"-"`
 }
 
 // a raw notification provides a low-level interface to the f.d.o. dbus
@@ -87,11 +91,32 @@
 
 // WatchActions listens for ActionInvoked signals from the notification daemon
 // and sends them over the channel provided
-func (raw *RawNotifications) WatchActions() (<-chan RawActionReply, error) {
-	ch := make(chan RawActionReply)
+func (raw *RawNotifications) WatchActions() (<-chan *RawAction, error) {
+	ch := make(chan *RawAction)
 	err := raw.bus.WatchSignal("ActionInvoked",
 		func(ns ...interface{}) {
-			ch <- RawActionReply{ns[0].(uint32), ns[1].(string)}
+			if len(ns) != 2 {
+				raw.log.Debugf("ActionInvoked delivered %d things instead of 2", len(ns))
+				return
+			}
+			rawId, ok := ns[0].(uint32)
+			if !ok {
+				raw.log.Debugf("ActionInvoked's 1st param not a uint32")
+				return
+			}
+			encodedAction, ok := ns[1].(string)
+			if !ok {
+				raw.log.Debugf("ActionInvoked's 2nd param not a string")
+				return
+			}
+			var action *RawAction
+			err := json.Unmarshal([]byte(encodedAction), &action)
+			if err != nil {
+				raw.log.Debugf("ActionInvoked's 2nd param not a json-encoded RawAction")
+				return
+			}
+			action.RawId = rawId
+			ch <- action
 		}, func() { close(ch) })
 	if err != nil {
 		raw.log.Debugf("Failed to set up the watch: %s", err)
@@ -100,35 +125,48 @@
 	return ch, nil
 }
 
-// ShowCard displays a given card.
+// Present displays a given card.
 //
+// If card.Actions is empty it's a plain, noninteractive bubble notification.
 // If card.Actions has 1 action, it's an interactive notification.
-// If card.Actions has 2 or more actions, it will show as a snap decision.
-//
-// WatchActions will receive something like this in the ActionId field:
-// appId::notificationId::action.Id
-func (raw *RawNotifications) Present(appId string, notificationId string, notification *launch_helper.Notification) (uint32, error) {
+// If card.Actions has 2 actions, it will show as a snap decision.
+// If it has more actions, who knows (good luck).
+func (raw *RawNotifications) Present(app *click.AppId, nid string, notification *launch_helper.Notification) (uint32, error) {
 	if notification == nil || notification.Card == nil || !notification.Card.Popup || notification.Card.Summary == "" {
-		raw.log.Debugf("skipping notification: nil, or nil card, or not popup, or no summary: %#v", notification)
+		raw.log.Debugf("[%s] skipping notification: nil, or nil card, or not popup, or no summary: %#v", nid, notification)
 		return 0, nil
 	}
 
 	card := notification.Card
 
-	app_icon := c_helper.AppIconFromId(appId)
 	hints := make(map[string]*dbus.Variant)
-	hints["x-canonical-secondary-icon"] = &dbus.Variant{app_icon}
+	hints["x-canonical-secondary-icon"] = &dbus.Variant{app.Icon()}
 
+	appId := app.Original()
 	actions := make([]string, 2*len(card.Actions))
 	for i, action := range card.Actions {
-		actions[2*i] = fmt.Sprintf("%s::%s::%d", appId, notificationId, i)
+		act, err := json.Marshal(&RawAction{
+			App:      app,
+			Nid:      nid,
+			ActionId: i,
+			Action:   action,
+		})
+		if err != nil {
+			return 0, err
+		}
+		actions[2*i] = string(act)
 		actions[2*i+1] = action
 	}
-	switch len(actions) {
+	switch len(card.Actions) {
+	case 0:
+		// nothing
+	case 1:
+		hints["x-canonical-switch-to-application"] = &dbus.Variant{"true"}
 	case 2:
-		hints["x-canonical-switch-to-application"] = &dbus.Variant{true}
-	case 4:
-		hints["x-canonical-snap-decisions"] = &dbus.Variant{true}
+		hints["x-canonical-snap-decisions"] = &dbus.Variant{"true"}
+		hints["x-canonical-private-button-tint"] = &dbus.Variant{"true"}
+	default:
+		raw.log.Debugf("[%s] don't know what to do with %d actions; no hints set", nid, len(card.Actions))
 	}
 	return raw.Notify(appId, 0, card.Icon, card.Summary, card.Body, actions, hints, 30*1000)
 }

=== modified file 'bus/notifications/raw_test.go'
--- bus/notifications/raw_test.go	2014-07-01 00:51:59 +0000
+++ bus/notifications/raw_test.go	2014-07-21 14:14:04 +0000
@@ -20,25 +20,33 @@
 package notifications
 
 import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/bus"
 	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/click"
+	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	"launchpad.net/ubuntu-push/launch_helper"
-	"launchpad.net/ubuntu-push/logger"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
-	"testing"
-	"time"
 )
 
 // hook up gocheck
 func TestRaw(t *testing.T) { TestingT(t) }
 
 type RawSuite struct {
-	log logger.Logger
+	log *helpers.TestLogger
+	app *click.AppId
 }
 
 func (s *RawSuite) SetUpTest(c *C) {
 	s.log = helpers.NewTestLogger(c, "debug")
+	s.app = clickhelp.MustParseAppId("com.example.test_test-app_0")
 }
 
 var _ = Suite(&RawSuite{})
@@ -72,16 +80,25 @@
 }
 
 func (s *RawSuite) TestWatchActions(c *C) {
+	act := &RawAction{
+		App:      clickhelp.MustParseAppId("_foo"),
+		Nid:      "notif-id",
+		ActionId: 1,
+		Action:   "hello",
+		RawId:    0,
+	}
+	jAct, err := json.Marshal(act)
+	c.Assert(err, IsNil)
 	endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true),
-		[]interface{}{uint32(1), "hello"})
+		[]interface{}{uint32(1), string(jAct)})
 	raw := Raw(endp, s.log)
 	ch, err := raw.WatchActions()
 	c.Assert(err, IsNil)
 	// check we get the right action reply
+	act.RawId = 1 // checking the RawId is overwritten with the one in the ActionInvoked
 	select {
 	case p := <-ch:
-		c.Check(p.NotificationId, Equals, uint32(1))
-		c.Check(p.ActionId, Equals, "hello")
+		c.Check(p, DeepEquals, act)
 	case <-time.NewTimer(time.Second / 10).C:
 		c.Error("timed out?")
 	}
@@ -90,6 +107,49 @@
 	c.Check(ok, Equals, false)
 }
 
+type tst struct {
+	errstr string
+	endp   bus.Endpoint
+	works  bool
+}
+
+func (s *RawSuite) TestWatchActionsToleratesDBusWeirdness(c *C) {
+	X := func(errstr string, args ...interface{}) tst {
+		endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), args)
+		// stop the endpoint from closing the channel:
+		testibus.SetWatchTicker(endp, make(chan bool))
+		return tst{errstr, endp, errstr == ""}
+	}
+
+	ts := []tst{
+		X("delivered 0 things instead of 2"),
+		X("delivered 1 things instead of 2", 2),
+		X("1st param not a uint32", 1, "foo"),
+		X("2nd param not a string", uint32(1), nil),
+		X("2nd param not a json-encoded RawAction", uint32(1), ``),
+		X("", uint32(1), `{}`),
+	}
+
+	for i, t := range ts {
+		raw := Raw(t.endp, s.log)
+		ch, err := raw.WatchActions()
+		c.Assert(err, IsNil)
+		select {
+		case p := <-ch:
+			if !t.works {
+				c.Errorf("got something on the channel! %#v (iter: %d)", p, i)
+			}
+		case <-time.After(time.Second / 10):
+			if t.works {
+				c.Errorf("failed to get something on the channel (iter: %d)", i)
+			}
+		}
+		c.Check(s.log.Captured(), Matches, `(?ms).*`+t.errstr+`.*`)
+		s.log.ResetCapture()
+	}
+
+}
+
 func (s *RawSuite) TestWatchActionsFails(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
 	raw := Raw(endp, s.log)
@@ -100,15 +160,86 @@
 func (s *RawSuite) TestPresentNotifies(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	nid, err := raw.Present("firefox.desktop", "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true}})
+	nid, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true}})
 	c.Check(err, IsNil)
 	c.Check(nid, Equals, uint32(1))
 }
 
+func (s *RawSuite) TestPresentOneAction(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	_, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true, Actions: []string{"Yes"}}})
+	c.Check(err, IsNil)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Assert(callArgs[0].Member, Equals, "Notify")
+	c.Assert(len(callArgs[0].Args), Equals, 8)
+	actions, ok := callArgs[0].Args[5].([]string)
+	c.Assert(ok, Equals, true)
+	c.Assert(actions, HasLen, 2)
+	c.Check(actions[0], Equals, `{"app":"com.example.test_test-app_0","act":"Yes","nid":"notifId"}`)
+	c.Check(actions[1], Equals, "Yes")
+	hints, ok := callArgs[0].Args[6].(map[string]*dbus.Variant)
+	c.Assert(ok, Equals, true)
+	// with one action, there should be 2 hints set:
+	c.Assert(hints, HasLen, 2)
+	c.Check(hints["x-canonical-switch-to-application"], NotNil)
+	c.Check(hints["x-canonical-secondary-icon"], NotNil)
+	c.Check(hints["x-canonical-snap-decisions"], IsNil)
+	c.Check(hints["x-canonical-private-button-tint"], IsNil)
+}
+
+func (s *RawSuite) TestPresentTwoActions(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	_, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true, Actions: []string{"Yes", "No"}}})
+	c.Check(err, IsNil)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Assert(callArgs[0].Member, Equals, "Notify")
+	c.Assert(len(callArgs[0].Args), Equals, 8)
+	actions, ok := callArgs[0].Args[5].([]string)
+	c.Assert(ok, Equals, true)
+	c.Assert(actions, HasLen, 4)
+	c.Check(actions[0], Equals, `{"app":"com.example.test_test-app_0","act":"Yes","nid":"notifId"}`)
+	c.Check(actions[1], Equals, "Yes")
+	c.Check(actions[2], Equals, `{"app":"com.example.test_test-app_0","act":"No","aid":1,"nid":"notifId"}`)
+	c.Check(actions[3], Equals, "No")
+	hints, ok := callArgs[0].Args[6].(map[string]*dbus.Variant)
+	c.Assert(ok, Equals, true)
+	// with two actions, there should be 3 hints set:
+	c.Assert(hints, HasLen, 3)
+	c.Check(hints["x-canonical-switch-to-application"], IsNil)
+	c.Check(hints["x-canonical-secondary-icon"], NotNil)
+	c.Check(hints["x-canonical-snap-decisions"], NotNil)
+	c.Check(hints["x-canonical-private-button-tint"], NotNil)
+	c.Check(hints["x-canonical-non-shaped-icon"], IsNil) // checking just in case
+}
+
+func (s *RawSuite) TestPresentThreeActions(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	_, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true, Actions: []string{"Yes", "No", "What"}}})
+	c.Check(err, IsNil)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Assert(callArgs[0].Member, Equals, "Notify")
+	c.Assert(len(callArgs[0].Args), Equals, 8)
+	actions, ok := callArgs[0].Args[5].([]string)
+	c.Assert(ok, Equals, true)
+	c.Assert(actions, HasLen, 6)
+	hints, ok := callArgs[0].Args[6].(map[string]*dbus.Variant)
+	c.Assert(ok, Equals, true)
+	// with two actions, there should be 3 hints set:
+	c.Check(hints, HasLen, 1)
+	c.Check(hints["x-canonical-secondary-icon"], NotNil)
+	c.Check(s.log.Captured(), Matches, `(?ms).* no hints set$`)
+}
+
 func (s *RawSuite) TestPresentNoNotificationDoesNotNotify(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	nid, err := raw.Present("firefox.desktop", "notifId", nil)
+	nid, err := raw.Present(s.app, "notifId", nil)
 	c.Check(err, IsNil)
 	c.Check(nid, Equals, uint32(0))
 }
@@ -116,7 +247,7 @@
 func (s *RawSuite) TestPresentNoCardDoesNotNotify(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	nid, err := raw.Present("firefox.desktop", "notifId", &launch_helper.Notification{})
+	nid, err := raw.Present(s.app, "notifId", &launch_helper.Notification{})
 	c.Check(err, IsNil)
 	c.Check(nid, Equals, uint32(0))
 }
@@ -124,7 +255,7 @@
 func (s *RawSuite) TestPresentNoSummaryDoesNotNotify(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	nid, err := raw.Present("firefox.desktop", "notifId", &launch_helper.Notification{Card: &launch_helper.Card{}})
+	nid, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{}})
 	c.Check(err, IsNil)
 	c.Check(nid, Equals, uint32(0))
 }
@@ -132,9 +263,7 @@
 func (s *RawSuite) TestPresentNoPopupNoNotify(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)
-	nid, err := raw.Present("firefox.desktop", "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary"}})
+	nid, err := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary"}})
 	c.Check(err, IsNil)
 	c.Check(nid, Equals, uint32(0))
 }
-
-// XXX Missing test about ShowCard manipulating Actions and hints correctly.

=== added directory 'bus/windowstack'
=== added file 'bus/windowstack/windowstack.go'
--- bus/windowstack/windowstack.go	1970-01-01 00:00:00 +0000
+++ bus/windowstack/windowstack.go	2014-07-21 14:14:04 +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 windowstack retrieves information about the windowstack
+// using Unity's dbus interface
+package windowstack
+
+import (
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+// Well known address for the WindowStack API
+var BusAddress bus.Address = bus.Address{
+	Interface: "com.canonical.Unity.WindowStack",
+	Path:      "/com/canonical/Unity/WindowStack",
+	Name:      "com.canonical.Unity.WindowStack",
+}
+
+type WindowsInfo struct {
+	WindowId uint32
+	AppId    string // in the form "com.ubuntu.calendar_calendar" or "webbrowser-app"
+	Focused  bool
+	Stage    uint32
+}
+
+// WindowStack encapsulates info needed to call out to the WindowStack API
+type WindowStack struct {
+	bus bus.Endpoint
+	log logger.Logger
+}
+
+// New returns a new WindowStack that'll use the provided bus.Endpoint
+func New(endp bus.Endpoint, log logger.Logger) *WindowStack {
+	return &WindowStack{endp, log}
+}
+
+// GetWindowStack returns the window stack state
+func (stack *WindowStack) GetWindowStack() []WindowsInfo {
+	var wstack []WindowsInfo
+	err := stack.bus.Call("GetWindowStack", bus.Args(), &wstack)
+	if err != nil {
+		stack.log.Errorf("GetWindowStack call returned %v", err)
+	}
+	return wstack
+}
+
+func (stack *WindowStack) IsAppFocused(AppId *click.AppId) bool {
+	for _, winfo := range stack.GetWindowStack() {
+		if winfo.Focused && winfo.AppId == AppId.Base() {
+			return true
+		}
+	}
+	return false
+}

=== added file 'bus/windowstack/windowstack_test.go'
--- bus/windowstack/windowstack_test.go	1970-01-01 00:00:00 +0000
+++ bus/windowstack/windowstack_test.go	2014-07-21 14:14:04 +0000
@@ -0,0 +1,93 @@
+/*
+ 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 windowstack
+
+import (
+	"testing"
+
+	. "launchpad.net/gocheck"
+
+	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/click"
+	clickhelp "launchpad.net/ubuntu-push/click/testing"
+	helpers "launchpad.net/ubuntu-push/testing"
+	"launchpad.net/ubuntu-push/testing/condition"
+)
+
+func TestWindowStack(t *testing.T) { TestingT(t) }
+
+type stackSuite struct {
+	log *helpers.TestLogger
+	app *click.AppId
+}
+
+var _ = Suite(&stackSuite{})
+
+func (hs *stackSuite) SetUpTest(c *C) {
+	hs.log = helpers.NewTestLogger(c, "debug")
+	hs.app = clickhelp.MustParseAppId("com.example.test_test-app_0")
+}
+
+// Checks that GetWindowStack() actually calls GetWindowStack
+func (ss *stackSuite) TestGetsWindowStack(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), []WindowsInfo{})
+	ec := New(endp, ss.log)
+	c.Check(ec.GetWindowStack(), DeepEquals, []WindowsInfo{})
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Check(callArgs[0].Member, Equals, "GetWindowStack")
+	c.Check(callArgs[0].Args, DeepEquals, []interface{}(nil))
+}
+
+var isFocusedTests = []struct {
+	expected bool          // expected result
+	wstack   []WindowsInfo // window stack data
+}{
+	{
+		false,
+		[]WindowsInfo{}, // No windows
+	},
+	{
+		true,
+		[]WindowsInfo{{0, "com.example.test_test-app", true, 0}}, // Just one window, matching app
+	},
+	{
+		false,
+		[]WindowsInfo{{0, "com.example.test_notest-app", true, 0}}, // Just one window, not matching app
+	},
+	{
+		true,
+		[]WindowsInfo{{0, "com.example.test_notest-app", false, 0}, {0, "com.example.test_test-app", true, 0}}, // Two windows, app focused
+	},
+	{
+		false,
+		[]WindowsInfo{{0, "com.example.test_notest-app", true, 0}, {0, "com.example.test_test-app", false, 0}}, // Two windows, app unfocused
+	},
+	{
+		true,
+		[]WindowsInfo{{0, "com.example.test_notest-app", true, 0}, {0, "com.example.test_test-app", true, 0}}, // Two windows, both focused
+	},
+}
+
+// Check that if the app is focused, IsAppFocused returns true
+func (ss *stackSuite) TestIsAppFocused(c *C) {
+	for _, t := range isFocusedTests {
+		endp := testibus.NewTestingEndpoint(nil, condition.Work(true), t.wstack)
+		ec := New(endp, ss.log)
+		c.Check(ec.IsAppFocused(ss.app), Equals, t.expected)
+	}
+}

=== renamed directory 'bus/notifications/app_helper' => 'click/cappinfo'
=== renamed file 'bus/notifications/app_helper/app_helper_c.go' => 'click/cappinfo/cappinfo.go'
--- bus/notifications/app_helper/app_helper_c.go	2014-07-03 15:05:48 +0000
+++ click/cappinfo/cappinfo.go	2014-07-21 14:14:04 +0000
@@ -14,17 +14,18 @@
  with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-// Package app_helper wraps C functions to access app information
-package app_helper
+// Package cappinfo wraps C functions to access app information
+
+package cappinfo
 
 /*
 #cgo pkg-config: gio-unix-2.0
 #include <glib.h>
 #include <gio/gdesktopappinfo.h>
 
-gchar* app_icon_filename_from_id (gchar* app_id) {
+gchar* app_icon_filename_from_desktop_id (gchar* desktop_id) {
     gchar* filename = NULL;
-    GAppInfo* app_info = (GAppInfo*)g_desktop_app_info_new (app_id);
+    GAppInfo* app_info = (GAppInfo*)g_desktop_app_info_new (desktop_id);
     if (app_info != NULL) {
         GIcon* icon = g_app_info_get_icon (app_info);
         if (icon != NULL) {
@@ -33,14 +34,14 @@
         }
         g_object_unref (app_info);
     }
-   g_free (app_id);
+   g_free (desktop_id);
    return filename;
 }
 */
 import "C"
 
-func AppIconFromId(appId string) string {
-	name := C.app_icon_filename_from_id((*C.gchar)(C.CString(appId)))
+func AppIconFromDesktopId(desktopId string) string {
+	name := C.app_icon_filename_from_desktop_id((*C.gchar)(C.CString(desktopId)))
 	defer C.g_free((C.gpointer)(name))
 	return C.GoString((*C.char)(name))
 }

=== modified file 'click/cclick/cclick.go'
--- click/cclick/cclick.go	2014-07-04 12:13:34 +0000
+++ click/cclick/cclick.go	2014-07-21 14:14:04 +0000
@@ -68,9 +68,3 @@
 	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
-}

=== modified file 'click/click.go'
--- click/click.go	2014-07-04 15:03:59 +0000
+++ click/click.go	2014-07-21 14:14:04 +0000
@@ -19,10 +19,18 @@
 package click
 
 import (
+	"encoding/json"
 	"errors"
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
 	"regexp"
+	"strings"
 	"sync"
 
+	"launchpad.net/go-xdg/v0"
+
+	"launchpad.net/ubuntu-push/click/cappinfo"
 	"launchpad.net/ubuntu-push/click/cclick"
 )
 
@@ -31,27 +39,151 @@
 	Package     string
 	Application string
 	Version     string
+	Click       bool
+	original    string
 }
 
+var hookPath = filepath.Join(xdg.Data.Home(), "ubuntu-push-client", "helpers")
+var hookExt = ".json"
+
 // 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 rxClick = regexp.MustCompile(`^([a-z0-9][a-z0-9+.-]+)_([a-zA-Z0-9+.-]+)(?:_([0-9][a-zA-Z0-9.+:~-]*))?$`)
+
+// no / and not starting with .
+var rxLegacy = regexp.MustCompile(`^[^./][^/]*$`)
 
 var (
 	ErrInvalidAppId = errors.New("invalid application id")
+	ErrMissingAppId = errors.New("missing 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
+	app := new(AppId)
+	err := app.setFromString(id)
+	if err == nil {
+		return app, nil
+	} else {
+		return nil, err
+	}
+}
+
+func (app *AppId) setFromString(id string) error {
+	if strings.HasPrefix(id, "_") { // legacy
+		appname := id[1:]
+		if !rxLegacy.MatchString(appname) {
+			return ErrInvalidAppId
+		}
+		app.Package = ""
+		app.Application = appname
+		app.Version = ""
+		app.Click = false
+		app.original = id
+		return nil
+	} else {
+		m := rxClick.FindStringSubmatch(id)
+		if len(m) == 0 {
+			return ErrInvalidAppId
+		}
+		app.Package = m[1]
+		app.Application = m[2]
+		app.Version = m[3]
+		app.Click = true
+		app.original = id
+		return nil
+	}
+}
+
+func (app *AppId) InPackage(pkgname string) bool {
+	return app.Package == pkgname
+}
+
+func (app *AppId) Original() string {
+	return app.original
+}
+
+func (app *AppId) String() string {
+	return app.Original()
+}
+
+func (app *AppId) Base() string {
+	if app.Click {
+		return app.Package + "_" + app.Application
+	} else {
+		return app.Application
+	}
+}
+
+type hookFile struct {
+	AppId string `json:"app_id"`
+	Exec  string `json:"exec"`
+}
+
+// Helper figures out the app id and executable of the untrusted
+// helper for this app.
+func (app *AppId) Helper() (helperAppId string, helperExec string) {
+	if !app.Click {
+		return "", ""
+	}
+	// xxx: should probably have a cache of this
+	matches, err := filepath.Glob(filepath.Join(hookPath, app.Package+"_*"+hookExt))
+	if err != nil {
+		return "", ""
+	}
+	var v hookFile
+	for _, m := range matches {
+		abs, err := filepath.EvalSymlinks(m)
+		if err != nil {
+			continue
+		}
+		data, err := ioutil.ReadFile(abs)
+		if err != nil {
+			continue
+		}
+		err = json.Unmarshal(data, &v)
+		if err != nil {
+			continue
+		}
+		if v.Exec != "" && (v.AppId == "" || v.AppId == app.Base()) {
+			basename := filepath.Base(m)
+			helperAppId = basename[:len(basename)-len(hookExt)]
+			helperExec = filepath.Join(filepath.Dir(abs), v.Exec)
+			return helperAppId, helperExec
+		}
+	}
+	return "", ""
+}
+
+func (app *AppId) Versioned() string {
+	if app.Click {
+		if app.Version == "" {
+			panic(fmt.Errorf("Versioned() on AppId without version/not verified: %#v", app))
+		}
+		return app.Package + "_" + app.Application + "_" + app.Version
+	} else {
+		return app.Application
+	}
+}
+
+func (app *AppId) DesktopId() string {
+	return app.Versioned() + ".desktop"
+}
+
+func (app *AppId) Icon() string {
+	return cappinfo.AppIconFromDesktopId(app.DesktopId())
+}
+
+func (app *AppId) MarshalJSON() ([]byte, error) {
+	return json.Marshal(app.Original())
+}
+
+func (app *AppId) UnmarshalJSON(s []byte) error {
+	var v string
+	err := json.Unmarshal(s, &v)
+	if err != nil {
+		return err
+	}
+	return app.setFromString(v)
 }
 
 // ClickUser exposes the click package registry for the user.
@@ -60,6 +192,24 @@
 	lock sync.Mutex
 }
 
+type InstalledChecker interface {
+	Installed(app *AppId, setVersion bool) bool
+}
+
+// ParseAndVerifyAppId parses the given app id and checks if the
+// corresponding app is installed, returning the parsed id or
+// ErrInvalidAppId, or the parsed id and ErrMissingAppId respectively.
+func ParseAndVerifyAppId(id string, installedChecker InstalledChecker) (*AppId, error) {
+	app, err := ParseAppId(id)
+	if err != nil {
+		return nil, err
+	}
+	if installedChecker != nil && !installedChecker.Installed(app, true) {
+		return app, ErrMissingAppId
+	}
+	return app, nil
+}
+
 // User makes a new ClickUser object for the current user.
 func User() (*ClickUser, error) {
 	cu := new(ClickUser)
@@ -70,17 +220,24 @@
 	return cu, nil
 }
 
-// HasPackage checks if the appId is installed for user.
-func (cu *ClickUser) HasPackage(appId string) bool {
+// Installed checks if the appId is installed for user, optionally setting
+// the version if it was absent.
+func (cu *ClickUser) Installed(app *AppId, setVersion bool) 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
+	if app.Click {
+		ver := cu.ccu.CGetVersion(app.Package)
+		if ver == "" {
+			return false
+		}
+		if app.Version != "" {
+			return app.Version == ver
+		} else if setVersion {
+			app.Version = ver
+		}
+		return true
 	} else {
-		return cu.ccu.CHasPackageName(id.Package)
+		_, err := xdg.Data.Find(filepath.Join("applications", app.DesktopId()))
+		return err == nil
 	}
 }

=== modified file 'click/click_test.go'
--- click/click_test.go	2014-07-04 12:35:41 +0000
+++ click/click_test.go	2014-07-21 14:14:04 +0000
@@ -17,6 +17,10 @@
 package click
 
 import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
 	"testing"
 
 	. "launchpad.net/gocheck"
@@ -29,30 +33,79 @@
 var _ = Suite(&clickSuite{})
 
 func (cs *clickSuite) TestParseAppId(c *C) {
-	id, err := ParseAppId("com.ubuntu.clock_clock")
+	app, 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, "")
+	c.Check(app.Package, Equals, "com.ubuntu.clock")
+	c.Check(app.InPackage("com.ubuntu.clock"), Equals, true)
+	c.Check(app.Application, Equals, "clock")
+	c.Check(app.Version, Equals, "")
+	c.Check(app.Click, Equals, true)
+	c.Check(app.Original(), Equals, "com.ubuntu.clock_clock")
+	c.Check(fmt.Sprintf("%s", app), Equals, "com.ubuntu.clock_clock")
 
-	id, err = ParseAppId("com.ubuntu.clock_clock_10")
+	app, 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")
+	c.Check(app.Package, Equals, "com.ubuntu.clock")
+	c.Check(app.InPackage("com.ubuntu.clock"), Equals, true)
+	c.Check(app.Application, Equals, "clock")
+	c.Check(app.Version, Equals, "10")
+	c.Check(app.Click, Equals, true)
+	c.Check(app.Original(), Equals, "com.ubuntu.clock_clock_10")
+	c.Check(fmt.Sprintf("%s", app), Equals, "com.ubuntu.clock_clock_10")
+	c.Check(app.Versioned(), Equals, "com.ubuntu.clock_clock_10")
+	c.Check(app.Base(), Equals, "com.ubuntu.clock_clock")
+	c.Check(app.DesktopId(), Equals, "com.ubuntu.clock_clock_10.desktop")
 
 	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)
+		app, err = ParseAppId(s)
+		c.Check(app, IsNil)
+		c.Check(err, Equals, ErrInvalidAppId)
+	}
+}
+
+func (cs *clickSuite) TestVersionedPanic(c *C) {
+	app, err := ParseAppId("com.ubuntu.clock_clock")
+	c.Assert(err, IsNil)
+	c.Check(func() { app.Versioned() }, PanicMatches, `Versioned\(\) on AppId without version/not verified:.*`)
+}
+
+func (cs *clickSuite) TestParseAppIdLegacy(c *C) {
+	app, err := ParseAppId("_python3.4")
+	c.Assert(err, IsNil)
+	c.Check(app.Package, Equals, "")
+	c.Check(app.InPackage(""), Equals, true)
+	c.Check(app.Application, Equals, "python3.4")
+	c.Check(app.Version, Equals, "")
+	c.Check(app.Click, Equals, false)
+	c.Check(app.Original(), Equals, "_python3.4")
+	c.Check(app.Versioned(), Equals, "python3.4")
+	c.Check(app.Base(), Equals, "python3.4")
+	c.Check(app.DesktopId(), Equals, "python3.4.desktop")
+
+	for _, s := range []string{"_.foo", "_foo/", "_/foo"} {
+		app, err = ParseAppId(s)
+		c.Check(app, IsNil)
+		c.Check(err, Equals, ErrInvalidAppId)
+	}
+}
+
+func (cs *clickSuite) TestJSON(c *C) {
+	for _, appId := range []string{"com.ubuntu.clock_clock", "com.ubuntu.clock_clock_10", "_python3.4"} {
+		app, err := ParseAppId(appId)
+		c.Assert(err, IsNil, Commentf(appId))
+		b, err := json.Marshal(app)
+		c.Assert(err, IsNil, Commentf(appId))
+		var vapp *AppId
+		err = json.Unmarshal(b, &vapp)
+		c.Assert(err, IsNil, Commentf(appId))
+		c.Check(vapp, DeepEquals, app)
+	}
+}
+
+func (cs *clickSuite) TestIcon(c *C) {
+	app, err := ParseAppId("_python3.4")
+	c.Assert(err, IsNil)
+	c.Check(app.Icon(), Equals, "/usr/share/pixmaps/python3.4.xpm")
 }
 
 func (s *clickSuite) TestUser(c *C) {
@@ -61,26 +114,144 @@
 	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) {
+func (s *clickSuite) TestInstalledNegative(c *C) {
+	u, err := User()
+	c.Assert(err, IsNil)
+	app, err := ParseAppId("com.foo.bar_baz")
+	c.Assert(err, IsNil)
+	c.Check(u.Installed(app, false), Equals, false)
+}
+
+func (s *clickSuite) TestInstalledVersionNegative(c *C) {
+	u, err := User()
+	c.Assert(err, IsNil)
+	app, err := ParseAppId("com.ubuntu.clock_clock_1000.0")
+	c.Assert(err, IsNil)
+	c.Check(u.Installed(app, false), Equals, false)
+}
+
+func (s *clickSuite) TestInstalledClock(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)
+	app, err := ParseAppId("com.ubuntu.clock_clock")
+	c.Assert(err, IsNil)
+	c.Check(u.Installed(app, false), Equals, true)
+	app, err = ParseAppId("com.ubuntu.clock_clock_" + ver)
+	c.Assert(err, IsNil)
+	c.Check(u.Installed(app, false), Equals, true)
+
+	app, err = ParseAppId("com.ubuntu.clock_clock_10" + ver)
+	c.Assert(err, IsNil)
+	c.Check(u.Installed(app, false), Equals, false)
+
+	// setVersion
+	app, err = ParseAppId("com.ubuntu.clock_clock")
+	c.Assert(err, IsNil)
+	c.Check(u.Installed(app, true), Equals, true)
+	c.Check(app.Version, Equals, ver)
+}
+
+func (s *clickSuite) TestInstalledLegacy(c *C) {
+	u, err := User()
+	c.Assert(err, IsNil)
+	app, err := ParseAppId("_python3.4")
+	c.Assert(err, IsNil)
+	c.Check(u.Installed(app, false), Equals, true)
+}
+
+func (s *clickSuite) TestParseAndVerifyAppId(c *C) {
+	u, err := User()
+	c.Assert(err, IsNil)
+
+	app, err := ParseAndVerifyAppId("_.foo", nil)
+	c.Assert(err, Equals, ErrInvalidAppId)
+	c.Check(app, IsNil)
+
+	app, err = ParseAndVerifyAppId("com.foo.bar_baz", nil)
+	c.Assert(err, IsNil)
+	c.Check(app.Click, Equals, true)
+	c.Check(app.Application, Equals, "baz")
+
+	app, err = ParseAndVerifyAppId("_non-existent-app", u)
+	c.Assert(err, Equals, ErrMissingAppId)
+	c.Check(app, NotNil)
+	c.Check(app.Original(), Equals, "_non-existent-app")
+
+}
+
+type helperSuite struct {
+	oldHookPath string
+	symlinkPath string
+}
+
+var _ = Suite(&helperSuite{})
+
+func (s *helperSuite) SetUpTest(c *C) {
+	s.oldHookPath = hookPath
+	hookPath = c.MkDir()
+	s.symlinkPath = c.MkDir()
+}
+
+func (s *helperSuite) createHookfile(name string, content string) error {
+	symlink := filepath.Join(hookPath, name) + ".json"
+	filename := filepath.Join(s.symlinkPath, name)
+	f, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	_, err = f.WriteString(content)
+	if err != nil {
+		return err
+	}
+	err = os.Symlink(filename, symlink)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *helperSuite) TearDownTest(c *C) {
+	hookPath = s.oldHookPath
+}
+
+func (s *helperSuite) TestHelperBasic(c *C) {
+	c.Assert(s.createHookfile("com.example.test_test-helper_1", `{"exec": "tsthlpr"}`), IsNil)
+	app, err := ParseAppId("com.example.test_test-app_1")
+	c.Assert(err, IsNil)
+	hid, hex := app.Helper()
+	c.Check(hid, Equals, "com.example.test_test-helper_1")
+	c.Check(hex, Equals, filepath.Join(s.symlinkPath, "tsthlpr"))
+}
+
+func (s *helperSuite) TestHelperFindsSpecific(c *C) {
+	// Glob() sorts, so the first one will come first
+	c.Assert(s.createHookfile("com.example.test_aaaa-helper_1", `{"exec": "aaaaaaa", "app_id": "com.example.test_test-other-app"}`), IsNil)
+	c.Assert(s.createHookfile("com.example.test_test-helper_1", `{"exec": "tsthlpr", "app_id": "com.example.test_test-app"}`), IsNil)
+	app, err := ParseAppId("com.example.test_test-app_1")
+	c.Assert(err, IsNil)
+	hid, hex := app.Helper()
+	c.Check(hid, Equals, "com.example.test_test-helper_1")
+	c.Check(hex, Equals, filepath.Join(s.symlinkPath, "tsthlpr"))
+}
+
+func (s *helperSuite) TestHelperCanFail(c *C) {
+	c.Assert(s.createHookfile("com.example.test_aaaa-helper_1", `{"exec": "aaaaaaa", "app_id": "com.example.test_test-other-app"}`), IsNil)
+	app, err := ParseAppId("com.example.test_test-app_1")
+	c.Assert(err, IsNil)
+	hid, hex := app.Helper()
+	c.Check(hid, Equals, "")
+	c.Check(hex, Equals, "")
+}
+
+func (s *clickSuite) TestHelperlegacy(c *C) {
+	appname := "ubuntu-system-settings"
+	app, err := ParseAppId("_" + appname)
+	c.Assert(err, IsNil)
+	hid, hex := app.Helper()
+	c.Check(hid, Equals, "")
+	c.Check(hex, Equals, "")
 }

=== added directory 'click/testing'
=== added file 'click/testing/helpers.go'
--- click/testing/helpers.go	1970-01-01 00:00:00 +0000
+++ click/testing/helpers.go	2014-07-21 14:14:04 +0000
@@ -0,0 +1,31 @@
+/*
+ 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 testing contains helpers for testing related to click.
+package testing
+
+import (
+	"launchpad.net/ubuntu-push/click"
+)
+
+// MustParseAppId parses an appId or panics.
+func MustParseAppId(appId string) *click.AppId {
+	app, err := click.ParseAppId(appId)
+	if err != nil {
+		panic(err)
+	}
+	return app
+}

=== modified file 'client/client.go'
--- client/client.go	2014-07-06 13:57:37 +0000
+++ client/client.go	2014-07-21 14:14:04 +0000
@@ -22,6 +22,7 @@
 	"crypto/sha256"
 	"encoding/base64"
 	"encoding/hex"
+	"encoding/json"
 	"encoding/pem"
 	"errors"
 	"fmt"
@@ -31,14 +32,12 @@
 	"os/exec"
 	"strings"
 
+	"code.google.com/p/go-uuid/uuid"
+
 	"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"
@@ -80,35 +79,40 @@
 	Unregister(appId string) error
 }
 
+type PostalService interface {
+	// Starts the service
+	Start() error
+	// Post converts a push message into a presentable notification
+	// and a postal message, presents the former and stores the
+	// latter in the application's mailbox.
+	Post(app *click.AppId, nid string, payload json.RawMessage) error
+	// IsRunning() returns whether the service is running
+	IsRunning() bool
+	// Stop() stops the service
+	Stop()
+}
+
 // PushClient is the Ubuntu Push Notifications client-side daemon.
 type PushClient struct {
-	leveldbPath           string
-	configPath            string
-	config                ClientConfig
-	log                   logger.Logger
-	pem                   []byte
-	idder                 identifier.Id
-	deviceId              string
-	notificationsEndp     bus.Endpoint
-	urlDispatcherEndp     bus.Endpoint
-	connectivityEndp      bus.Endpoint
-	emblemcounterEndp     bus.Endpoint
-	hapticEndp            bus.Endpoint
-	systemImageEndp       bus.Endpoint
-	systemImageInfo       *systemimage.InfoResult
-	connCh                chan bool
-	hasConnectivity       bool
-	actionsCh             <-chan notifications.RawActionReply
-	session               *session.ClientSession
-	sessionConnectedCh    chan uint32
-	pushServiceEndpoint   bus.Endpoint
-	pushService           PushService
-	postalServiceEndpoint bus.Endpoint
-	postalService         *service.PostalService
-	unregisterCh          chan string
-	trackAddressees       map[string]bool
-	clickUser             *click.ClickUser
-	hasPackage            func(string) bool
+	leveldbPath        string
+	configPath         string
+	config             ClientConfig
+	log                logger.Logger
+	pem                []byte
+	idder              identifier.Id
+	deviceId           string
+	connectivityEndp   bus.Endpoint
+	systemImageEndp    bus.Endpoint
+	systemImageInfo    *systemimage.InfoResult
+	connCh             chan bool
+	hasConnectivity    bool
+	session            *session.ClientSession
+	sessionConnectedCh chan uint32
+	pushService        PushService
+	postalService      PostalService
+	unregisterCh       chan *click.AppId
+	trackAddressees    map[string]*click.AppId
+	installedChecker   click.InstalledChecker
 }
 
 // Creates a new Ubuntu Push Notifications client-side daemon that will use
@@ -144,22 +148,15 @@
 	if err != nil {
 		return fmt.Errorf("libclick: %v", err)
 	}
-	client.clickUser = clickUser
 	// overridden for testing
-	client.hasPackage = clickUser.HasPackage
+	client.installedChecker = clickUser
 
-	client.unregisterCh = make(chan string, 10)
+	client.unregisterCh = make(chan *click.AppId, 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)
-	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)
@@ -204,6 +201,7 @@
 	setup.RegURL = purl
 	setup.DeviceId = client.deviceId
 	setup.AuthGetter = client.getAuthorization
+	setup.InstalledChecker = client.installedChecker
 	return setup, nil
 }
 
@@ -246,12 +244,7 @@
 func (client *PushClient) takeTheBus() error {
 	go connectivity.ConnectedState(client.connectivityEndp,
 		client.config.ConnectivityConfig, client.log, client.connCh)
-	iniCh := make(chan uint32)
-	go func() { iniCh <- util.NewAutoRedialer(client.urlDispatcherEndp).Redial() }()
-	go func() { iniCh <- util.NewAutoRedialer(client.systemImageEndp).Redial() }()
-	<-iniCh
-	<-iniCh
-
+	util.NewAutoRedialer(client.systemImageEndp).Redial()
 	sysimg := systemimage.New(client.systemImageEndp, client.log)
 	info, err := sysimg.Info()
 	if err != nil {
@@ -261,12 +254,6 @@
 	return err
 }
 
-func (client *PushClient) takePostalServiceBus() error {
-	actionsCh, err := client.postalService.TakeTheBus()
-	client.actionsCh = actionsCh
-	return err
-}
-
 // initSession creates the session object
 func (client *PushClient) initSession() error {
 	info := map[string]interface{}{
@@ -295,36 +282,44 @@
 
 // StartAddresseeBatch starts a batch of checks for addressees.
 func (client *PushClient) StartAddresseeBatch() {
-	client.trackAddressees = make(map[string]bool, 10)
+	client.trackAddressees = make(map[string]*click.AppId, 10)
 }
 
 // CheckForAddressee check for the addressee presence.
-func (client *PushClient) CheckForAddressee(notif *protocol.Notification) bool {
+func (client *PushClient) CheckForAddressee(notif *protocol.Notification) *click.AppId {
 	appId := notif.AppId
-	present, ok := client.trackAddressees[appId]
+	parsed, ok := client.trackAddressees[appId]
 	if ok {
-		return present
-	}
-	present = client.hasPackage(appId)
-	client.trackAddressees[appId] = present
-	if !present {
-		client.unregisterCh <- appId
-	}
-	return present
+		return parsed
+	}
+	parsed, err := click.ParseAndVerifyAppId(appId, client.installedChecker)
+	switch err {
+	default:
+		client.log.Debugf("notification %#v for invalid app id %#v.", notif.MsgId, notif.AppId)
+	case click.ErrMissingAppId:
+		client.log.Debugf("notification %#v for missing app id %#v.", notif.MsgId, notif.AppId)
+		client.unregisterCh <- parsed
+		parsed = nil
+	case nil:
+	}
+	client.trackAddressees[appId] = parsed
+	return parsed
 }
 
 // handleUnregister deals with tokens of uninstalled apps
-func (client *PushClient) handleUnregister(appId string) {
-	if !client.hasPackage(appId) {
+func (client *PushClient) handleUnregister(app *click.AppId) {
+	if !client.installedChecker.Installed(app, false) {
 		// 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)
+		err := client.pushService.Unregister(app.Original()) // XXX WIP
 		if err != nil {
-			client.log.Errorf("unregistering %s: %s", appId, err)
+			client.log.Errorf("unregistering %s: %s", app, err)
+		} else {
+			client.log.Debugf("unregistered token for %s", app)
 		}
 	}
 }
@@ -398,69 +393,52 @@
 // handleBroadcastNotification deals with receiving a broadcast notification
 func (client *PushClient) handleBroadcastNotification(msg *session.BroadcastNotification) error {
 	if !client.filterBroadcastNotification(msg) {
+		client.log.Debugf("not posting broadcast notification %d; filtered.", msg.TopLevel)
 		return nil
 	}
-	not_id, err := client.postalService.InjectBroadcast()
+	// marshal the last decoded msg to json
+	payload, err := json.Marshal(msg.Decoded[len(msg.Decoded)-1])
+	if err == nil {
+		appId, _ := click.ParseAppId("_ubuntu-system-settings")
+		err = client.postalService.Post(appId, uuid.New(), payload)
+	}
 	if err != nil {
-		client.log.Errorf("showing notification: %s", err)
-		return err
+		client.log.Errorf("while posting broadcast notification %d: %v", msg.TopLevel, err)
+	} else {
+		client.log.Debugf("posted broadcast notification %d.", msg.TopLevel)
 	}
-	client.log.Debugf("got notification id %d", not_id)
-	return nil
+	return err
 }
 
 // handleUnicastNotification deals with receiving a unicast notification
-func (client *PushClient) handleUnicastNotification(msg *protocol.Notification) error {
-	appId, err := click.ParseAppId(msg.AppId)
+func (client *PushClient) handleUnicastNotification(anotif session.AddressedNotification) error {
+	app := anotif.To
+	msg := anotif.Notification
+	err := client.postalService.Post(app, msg.MsgId, msg.Payload)
 	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(appId.Package, msg.AppId, msg.MsgId, string(msg.Payload))
-}
-
-// handleClick deals with the user clicking a notification
-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 := 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
-	}
-	// it doesn't get much simpler...
-	urld := urldispatcher.New(client.urlDispatcherEndp, client.log)
-	return urld.DispatchURL(url)
+		client.log.Errorf("while posting unicast notification %s for %s: %v", msg.MsgId, msg.AppId, err)
+	} else {
+		client.log.Debugf("posted unicast notification %s for %s.", msg.MsgId, msg.AppId)
+	}
+	return err
 }
 
 // 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), unregisterhandler func(string)) {
+func (client *PushClient) doLoop(connhandler func(bool), bcasthandler func(*session.BroadcastNotification) error, ucasthandler func(session.AddressedNotification) error, errhandler func(error), unregisterhandler func(*click.AppId)) {
 	for {
 		select {
 		case state := <-client.connCh:
 			connhandler(state)
-		case action := <-client.actionsCh:
-			clickhandler(action.ActionId)
 		case bcast := <-client.session.BroadcastCh:
 			bcasthandler(bcast)
-		case ucast := <-client.session.NotificationsCh:
-			ucasthandler(ucast)
+		case aucast := <-client.session.NotificationsCh:
+			ucasthandler(aucast)
 		case err := <-client.session.ErrCh:
 			errhandler(err)
 		case count := <-client.sessionConnectedCh:
 			client.log.Debugf("Session connected after %d attempts", count)
-		case appId := <-client.unregisterCh:
-			unregisterhandler(appId)
+		case app := <-client.unregisterCh:
+			unregisterhandler(app)
 		}
 	}
 }
@@ -479,20 +457,23 @@
 // Loop calls doLoop with the "real" handlers
 func (client *PushClient) Loop() {
 	client.doLoop(client.handleConnState,
-		client.handleClick,
 		client.handleBroadcastNotification,
 		client.handleUnicastNotification,
 		client.handleErr,
 		client.handleUnregister)
 }
 
-func (client *PushClient) startService() error {
+func (client *PushClient) setupPushService() error {
 	setup, err := client.derivePushServiceSetup()
 	if err != nil {
 		return err
 	}
 
-	client.pushService = service.NewPushService(client.pushServiceEndpoint, setup, client.log)
+	client.pushService = service.NewPushService(setup, client.log)
+	return nil
+}
+
+func (client *PushClient) startPushService() error {
 	if err := client.pushService.Start(); err != nil {
 		return err
 	}
@@ -500,7 +481,7 @@
 }
 
 func (client *PushClient) setupPostalService() error {
-	client.postalService = service.NewPostalService(client.postalServiceEndpoint, client.notificationsEndp, client.emblemcounterEndp, client.hapticEndp, client.log)
+	client.postalService = service.NewPostalService(client.installedChecker, client.log)
 	return nil
 }
 
@@ -516,11 +497,11 @@
 	return client.doStart(
 		client.configure,
 		client.getDeviceId,
-		client.startService,
+		client.setupPushService,
 		client.setupPostalService,
+		client.startPushService,
 		client.startPostalService,
 		client.takeTheBus,
-		client.takePostalServiceBus,
 		client.initSession,
 	)
 }

=== modified file 'client/client_test.go'
--- client/client_test.go	2014-07-07 10:35:51 +0000
+++ client/client_test.go	2014-07-21 14:14:04 +0000
@@ -34,9 +34,10 @@
 
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
-	"launchpad.net/ubuntu-push/bus/notifications"
 	"launchpad.net/ubuntu-push/bus/systemimage"
 	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/click"
+	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	"launchpad.net/ubuntu-push/client/service"
 	"launchpad.net/ubuntu-push/client/session"
 	"launchpad.net/ubuntu-push/client/session/seenstate"
@@ -61,6 +62,63 @@
 	}
 }
 
+type dumbCommon struct {
+	startCount   int
+	stopCount    int
+	runningCount int
+	running      bool
+	err          error
+}
+
+func (d *dumbCommon) Start() error {
+	d.startCount++
+	return d.err
+}
+func (d *dumbCommon) Stop() {
+	d.stopCount++
+}
+func (d *dumbCommon) IsRunning() bool {
+	d.runningCount++
+	return d.running
+}
+
+type dumbPush struct {
+	dumbCommon
+	unregCount int
+	unregArgs  []string
+}
+
+func (d *dumbPush) Unregister(appId string) error {
+	d.unregCount++
+	d.unregArgs = append(d.unregArgs, appId)
+	return d.err
+}
+
+type postArgs struct {
+	app     *click.AppId
+	nid     string
+	payload json.RawMessage
+}
+
+type dumbPostal struct {
+	dumbCommon
+	bcastCount int
+	postCount  int
+	postArgs   []postArgs
+}
+
+func (d *dumbPostal) Post(app *click.AppId, nid string, payload json.RawMessage) error {
+	d.postCount++
+	if app.Application == "ubuntu-system-settings" {
+		d.bcastCount++
+	}
+	d.postArgs = append(d.postArgs, postArgs{app, nid, payload})
+	return d.err
+}
+
+var _ PostalService = (*dumbPostal)(nil)
+var _ PushService = (*dumbPush)(nil)
+
 type clientSuite struct {
 	timeouts    []time.Duration
 	configPath  string
@@ -188,25 +246,12 @@
 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.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) {
@@ -223,7 +268,9 @@
 	err := cli.configure()
 	c.Assert(err, IsNil)
 	c.Assert(cli.unregisterCh, NotNil)
-	c.Assert(cli.hasPackage("com.bar.baz_foo"), Equals, false)
+	app, err := click.ParseAppId("com.bar.baz_foo")
+	c.Assert(err, IsNil)
+	c.Assert(cli.installedChecker.Installed(app, false), Equals, false)
 }
 
 func (cs *clientSuite) TestConfigureBailsOnBadFilename(c *C) {
@@ -279,29 +326,60 @@
     addresses checking tests
 ******************************************************************/
 
+type testInstalledChecker func(*click.AppId, bool) bool
+
+func (tic testInstalledChecker) Installed(app *click.AppId, setVersion bool) bool {
+	return tic(app, setVersion)
+}
+
+var (
+	appId1     = "com.example.app1_app1"
+	appId2     = "com.example.app2_app2"
+	appIdHello = "com.example.test_hello"
+	app1       = clickhelp.MustParseAppId(appId1)
+	app2       = clickhelp.MustParseAppId(appId2)
+	appHello   = clickhelp.MustParseAppId(appIdHello)
+)
+
 func (cs *clientSuite) TestCheckForAddressee(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.unregisterCh = make(chan string, 5)
+	cli.log = cs.log
+	cli.unregisterCh = make(chan *click.AppId, 5)
 	cli.StartAddresseeBatch()
 	calls := 0
-	cli.hasPackage = func(appId string) bool {
+	cli.installedChecker = testInstalledChecker(func(app *click.AppId, setVersion bool) bool {
 		calls++
-		if appId == "app1" {
+		c.Assert(setVersion, Equals, true)
+		if app.Original() == appId1 {
 			return false
 		}
 		return true
-	}
-	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: "app1"}), Equals, false)
+	})
+
+	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: "bad-id"}), IsNil)
+	c.Check(calls, Equals, 0)
+	c.Assert(cli.unregisterCh, HasLen, 0)
+	c.Check(cs.log.Captured(), Matches, `DEBUG notification "" for invalid app id "bad-id".\n`)
+	cs.log.ResetCapture()
+
+	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: appId1}), IsNil)
 	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(<-cli.unregisterCh, DeepEquals, app1)
+	c.Check(cs.log.Captured(), Matches, `DEBUG notification "" for missing app id "com.example.app1_app1".\n`)
+	cs.log.ResetCapture()
+
+	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: appId2}), DeepEquals, app2)
+	c.Check(calls, Equals, 2)
+	c.Check(cs.log.Captured(), Matches, "")
+	cs.log.ResetCapture()
+
+	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: appId1}), IsNil)
+	c.Check(calls, Equals, 2)
+	c.Check(cli.CheckForAddressee(&protocol.Notification{AppId: appId2}), DeepEquals, app2)
 	c.Check(calls, Equals, 2)
 	c.Check(cli.unregisterCh, HasLen, 0)
+	c.Check(cs.log.Captured(), Matches, "")
 }
 
 /*****************************************************************
@@ -358,9 +436,10 @@
 	c.Assert(err, IsNil)
 	cli.deviceId = "zoo"
 	expected := &service.PushServiceSetup{
-		DeviceId:   "zoo",
-		AuthGetter: func(string) string { return "" },
-		RegURL:     helpers.ParseURL("reg://"),
+		DeviceId:         "zoo",
+		AuthGetter:       func(string) string { return "" },
+		RegURL:           helpers.ParseURL("reg://"),
+		InstalledChecker: cli.installedChecker,
 	}
 	// sanity check that we are looking at all fields
 	vExpected := reflect.ValueOf(expected).Elem()
@@ -396,66 +475,59 @@
     startService tests
 ******************************************************************/
 
-func (cs *clientSuite) TestStartServiceWorks(c *C) {
-	cs.writeTestConfig(map[string]interface{}{
-		"auth_helper": helpers.ScriptAbsPath("dummyauth.sh"),
-	})
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	err := cli.configure()
-	c.Assert(err, IsNil)
-	cli.log = cs.log
-	cli.deviceId = "fake-id"
-	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
-	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
-	c.Check(cli.pushService, IsNil)
-	c.Check(cli.startService(), IsNil)
-	c.Assert(cli.pushService, NotNil)
-	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)
-	pushService.Stop()
-	cli.postalService.Stop()
-}
-
-func (cs *clientSuite) TestStartServiceSetupError(c *C) {
+func (cs *clientSuite) TestStartPushServiceCallsStart(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	d := new(dumbPush)
+	cli.pushService = d
+	c.Check(cli.startPushService(), IsNil)
+	c.Check(d.startCount, Equals, 1)
+}
+
+func (cs *clientSuite) TestStartPostServiceCallsStart(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	d := new(dumbPostal)
+	cli.postalService = d
+	c.Check(cli.startPostalService(), IsNil)
+	c.Check(d.startCount, Equals, 1)
+}
+
+func (cs *clientSuite) TestSetupPushServiceSetupError(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()
+	err = cli.setupPushService()
 	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)
-	c.Check(cli.startService(), NotNil)
-	c.Assert(cli.setupPostalService(), IsNil)
-	c.Assert(cli.startPostalService(), NotNil)
-}
-
-func (cs *clientSuite) TestStartServiceErrorsOnBusDialPushFail(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
-	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
-	c.Check(cli.startService(), NotNil)
-	c.Assert(cli.setupPostalService(), IsNil)
-	c.Assert(cli.startPostalService(), NotNil)
-}
-
-func (cs *clientSuite) TestStartServiceErrorsOnBusDialPostalFail(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	cli.pushServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), nil)
-	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(false), nil)
-	c.Check(cli.startService(), IsNil)
-	c.Assert(cli.setupPostalService(), IsNil)
-	c.Assert(cli.startPostalService(), NotNil)
+func (cs *clientSuite) TestSetupPushService(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	c.Assert(cli.configure(), IsNil)
+	c.Check(cli.pushService, IsNil)
+	c.Check(cli.setupPushService(), IsNil)
+	c.Check(cli.pushService, NotNil)
+}
+
+func (cs *clientSuite) TestStartPushErrorsOnPushStartError(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	d := new(dumbPush)
+	err := errors.New("potato")
+	d.err = err
+	cli.pushService = d
+	c.Check(cli.startPushService(), Equals, err)
+	c.Check(d.startCount, Equals, 1)
+}
+
+func (cs *clientSuite) TestStartPostalErrorsOnPostalStartError(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	d := new(dumbPostal)
+	err := errors.New("potato")
+	d.err = err
+	cli.postalService = d
+	c.Check(cli.startPostalService(), Equals, err)
+	c.Check(d.startCount, Equals, 1)
 }
 
 /*****************************************************************
@@ -499,11 +571,6 @@
 	defer ts.Close()
 
 	// testing endpoints
-	nCond := condition.Fail2Work(3)
-	nEndp := testibus.NewMultiValuedTestingEndpoint(nCond, condition.Work(true),
-		[]interface{}{uint32(1), "hello"})
-	uCond := condition.Fail2Work(5)
-	uEndp := testibus.NewTestingEndpoint(uCond, condition.Work(false))
 	cCond := condition.Fail2Work(7)
 	cEndp := testibus.NewTestingEndpoint(cCond, condition.Work(true),
 		uint32(networkmanager.ConnectedGlobal),
@@ -511,46 +578,26 @@
 	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
 	err := cli.configure()
 	c.Assert(err, IsNil)
-	// the user actions channel has not been set up
-	c.Check(cli.actionsCh, IsNil)
 
 	// and stomp on things for testing
 	cli.config.ConnectivityConfig.ConnectivityCheckURL = ts.URL
 	cli.config.ConnectivityConfig.ConnectivityCheckMD5 = staticHash
-	cli.notificationsEndp = nEndp
-	cli.urlDispatcherEndp = uEndp
 	cli.connectivityEndp = cEndp
-	cli.emblemcounterEndp = ecEndp
-	cli.hapticEndp = haEndp
 	cli.systemImageEndp = siEndp
 
 	c.Assert(cli.takeTheBus(), IsNil)
-	c.Assert(cli.setupPostalService(), IsNil)
-	c.Assert(cli.takePostalServiceBus(), IsNil)
-	// the notifications and urldispatcher endpoints retried until connected
-	c.Check(nCond.OK(), Equals, true)
-	c.Check(uCond.OK(), Equals, true)
-	// the user actions channel has now been set up
-	c.Check(cli.actionsCh, NotNil)
+
 	c.Check(takeNextBool(cli.connCh), Equals, false)
 	c.Check(takeNextBool(cli.connCh), Equals, true)
 	// the connectivity endpoint retried until connected
 	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
@@ -559,21 +606,13 @@
 	err := cli.configure()
 	cli.log = cs.log
 	c.Assert(err, IsNil)
-	// the user actions channel has not been set up
-	c.Check(cli.actionsCh, IsNil)
 
 	// and stomp on things for testing
-	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)
 	c.Assert(cli.setupPostalService(), IsNil)
-	c.Assert(cli.takePostalServiceBus(), NotNil)
-	c.Check(cli.actionsCh, IsNil)
 }
 
 /*****************************************************************
@@ -763,41 +802,40 @@
 func (cs *clientSuite) TestHandleBroadcastNotification(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.systemImageInfo = siInfoRes
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	cli.notificationsEndp = endp
 	cli.log = cs.log
-	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	cli.setupPostalService()
+	d := new(dumbPostal)
+	cli.postalService = d
 	c.Check(cli.handleBroadcastNotification(positiveBroadcastNotification), IsNil)
-	// check we sent the notification
-	args := testibus.GetCallArgs(endp)
-	c.Assert(args, HasLen, 1)
-	c.Check(args[0].Member, Equals, "Notify")
-	c.Check(cs.log.Captured(), Matches, `(?s).* got notification id \d+\s*`)
+	// we dun posted
+	c.Check(d.bcastCount, Equals, 1)
+	c.Assert(d.postArgs, HasLen, 1)
+	expectedApp, _ := click.ParseAppId("_ubuntu-system-settings")
+	c.Check(d.postArgs[0].app, DeepEquals, expectedApp)
+	expectedData, _ := json.Marshal(positiveBroadcastNotification.Decoded[0])
+	c.Check([]byte(d.postArgs[0].payload), DeepEquals, expectedData)
 }
 
 func (cs *clientSuite) TestHandleBroadcastNotificationNothingToDo(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.systemImageInfo = siInfoRes
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	cli.notificationsEndp = endp
 	cli.log = cs.log
+	d := new(dumbPostal)
+	cli.postalService = d
 	c.Check(cli.handleBroadcastNotification(negativeBroadcastNotification), IsNil)
-	// check we sent the notification
-	args := testibus.GetCallArgs(endp)
-	c.Assert(args, HasLen, 0)
-	c.Check(cs.log.Captured(), Matches, "")
+	// we not dun no posted
+	c.Check(d.bcastCount, Equals, 0)
 }
 
 func (cs *clientSuite) TestHandleBroadcastNotificationFail(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.systemImageInfo = siInfoRes
 	cli.log = cs.log
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
-	cli.notificationsEndp = endp
-	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	cli.setupPostalService()
-	c.Check(cli.handleBroadcastNotification(positiveBroadcastNotification), NotNil)
+	d := new(dumbPostal)
+	err := errors.New("potato")
+	d.err = err
+	cli.postalService = d
+	c.Check(cli.handleBroadcastNotification(positiveBroadcastNotification), Equals, err)
+	c.Check(d.bcastCount, Equals, 1)
 }
 
 /*****************************************************************
@@ -805,60 +843,34 @@
 ******************************************************************/
 
 var payload = `{"message": "aGVsbG8=", "notification": {"card": {"icon": "icon-value", "summary": "summary-value", "body": "body-value", "actions": []}}}`
-var notif = &protocol.Notification{AppId: "com.example.test_hello", Payload: []byte(payload), MsgId: "42"}
+var notif = &protocol.Notification{AppId: appIdHello, Payload: []byte(payload), MsgId: "42"}
 
 func (cs *clientSuite) TestHandleUcastNotification(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	postEndp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
-	cli.log = cs.log
-	cli.postalServiceEndpoint = postEndp
-	c.Assert(cli.setupPostalService(), IsNil)
-	c.Assert(cli.startPostalService(), IsNil)
-	c.Check(cli.handleUnicastNotification(notif), IsNil)
-	// check we sent the notification
-	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 "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
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
-	cli.urlDispatcherEndp = endp
-	// check we don't fail on something random
-	c.Check(cli.handleClick("something random"), IsNil)
-	// ... but we don't send anything either
-	args := testibus.GetCallArgs(endp)
-	c.Assert(args, HasLen, 0)
-	// check we worked with the right action id
-	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_PREFIX+"foo"), IsNil)
-	// check we sent the notification
-	args = testibus.GetCallArgs(endp)
-	c.Assert(args, HasLen, 2)
-	c.Check(args[1].Member, Equals, "DispatchURL")
-	c.Check(args[1].Args, DeepEquals, []interface{}{"foo"})
+	cli.log = cs.log
+	d := new(dumbPostal)
+	cli.postalService = d
+
+	c.Check(cli.handleUnicastNotification(session.AddressedNotification{appHello, notif}), IsNil)
+	// check we sent the notification
+	c.Check(d.postCount, Equals, 1)
+	c.Assert(d.postArgs, HasLen, 1)
+	c.Check(d.postArgs[0].app, Equals, appHello)
+	c.Check(d.postArgs[0].nid, Equals, notif.MsgId)
+	c.Check(d.postArgs[0].payload, DeepEquals, notif.Payload)
+}
+
+func (cs *clientSuite) TestHandleUcastNotificationError(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.log = cs.log
+	d := new(dumbPostal)
+	cli.postalService = d
+	fail := errors.New("fail")
+	d.err = fail
+
+	c.Check(cli.handleUnicastNotification(session.AddressedNotification{appHello, notif}), Equals, fail)
+	// check we sent the notification
+	c.Check(d.postCount, Equals, 1)
 }
 
 /*****************************************************************
@@ -882,41 +894,43 @@
 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")
+	cli.installedChecker = testInstalledChecker(func(app *click.AppId, setVersion bool) bool {
+		c.Check(setVersion, Equals, false)
+		c.Check(app.Original(), Equals, appId1)
 		return false
-	}
+	})
 	ps := &testPushService{}
 	cli.pushService = ps
-	cli.handleUnregister("app1")
-	c.Assert(ps.unregistered, Equals, "app1")
-	c.Check(cs.log.Captured(), Equals, "")
+	cli.handleUnregister(app1)
+	c.Assert(ps.unregistered, Equals, appId1)
+	c.Check(cs.log.Captured(), Equals, "DEBUG unregistered token for com.example.app1_app1\n")
 }
 
 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")
+	cli.installedChecker = testInstalledChecker(func(app *click.AppId, setVersion bool) bool {
+		c.Check(setVersion, Equals, false)
+		c.Check(app.Original(), Equals, appId1)
 		return true
-	}
+	})
 	ps := &testPushService{}
 	cli.pushService = ps
-	cli.handleUnregister("app1")
+	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 {
+	cli.installedChecker = testInstalledChecker(func(app *click.AppId, setVersion bool) 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")
+	cli.handleUnregister(app1)
+	c.Check(cs.log.Captured(), Matches, "ERROR unregistering com.example.app1_app1: BAD\n")
 }
 
 /*****************************************************************
@@ -924,11 +938,10 @@
 ******************************************************************/
 
 var nopConn = func(bool) {}
-var nopClick = func(string) error { return nil }
 var nopBcast = func(*session.BroadcastNotification) error { return nil }
-var nopUcast = func(*protocol.Notification) error { return nil }
+var nopUcast = func(session.AddressedNotification) error { return nil }
 var nopError = func(error) {}
-var nopUnregister = func(string) {}
+var nopUnregister = func(*click.AppId) {}
 
 func (cs *clientSuite) TestDoLoopConn(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
@@ -939,21 +952,7 @@
 	c.Assert(cli.initSession(), IsNil)
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(func(bool) { ch <- true }, nopClick, nopBcast, nopUcast, nopError, nopUnregister)
-	c.Check(takeNextBool(ch), Equals, true)
-}
-
-func (cs *clientSuite) TestDoLoopClick(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSession(), IsNil)
-	aCh := make(chan notifications.RawActionReply, 1)
-	aCh <- notifications.RawActionReply{}
-	cli.actionsCh = aCh
-
-	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, func(_ string) error { ch <- true; return nil }, nopBcast, nopUcast, nopError, nopUnregister)
+	go cli.doLoop(func(bool) { ch <- true }, nopBcast, nopUcast, nopError, nopUnregister)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -966,7 +965,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, nopUnregister)
+	go cli.doLoop(nopConn, func(_ *session.BroadcastNotification) error { ch <- true; return nil }, nopUcast, nopError, nopUnregister)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -975,11 +974,11 @@
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSession(), IsNil)
-	cli.session.NotificationsCh = make(chan *protocol.Notification, 1)
-	cli.session.NotificationsCh <- &protocol.Notification{}
+	cli.session.NotificationsCh = make(chan session.AddressedNotification, 1)
+	cli.session.NotificationsCh <- session.AddressedNotification{}
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, nopClick, nopBcast, func(*protocol.Notification) error { ch <- true; return nil }, nopError, nopUnregister)
+	go cli.doLoop(nopConn, nopBcast, func(session.AddressedNotification) error { ch <- true; return nil }, nopError, nopUnregister)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -992,7 +991,7 @@
 	cli.session.ErrCh <- nil
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, nopClick, nopBcast, nopUcast, func(error) { ch <- true }, nopUnregister)
+	go cli.doLoop(nopConn, nopBcast, nopUcast, func(error) { ch <- true }, nopUnregister)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -1001,11 +1000,11 @@
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSession(), IsNil)
-	cli.unregisterCh = make(chan string, 1)
-	cli.unregisterCh <- "app1"
+	cli.unregisterCh = make(chan *click.AppId, 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 })
+	go cli.doLoop(nopConn, nopBcast, nopUcast, nopError, func(app *click.AppId) { c.Check(app.Original(), Equals, appId1); ch <- true })
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -1044,17 +1043,14 @@
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.connCh = make(chan bool)
 	cli.sessionConnectedCh = make(chan uint32)
-	aCh := make(chan notifications.RawActionReply, 1)
-	cli.actionsCh = aCh
 	cli.log = cs.log
-	cli.notificationsEndp = testibus.NewMultiValuedTestingEndpoint(condition.Work(true),
-		condition.Work(true), []interface{}{uint32(1), "hello"})
-	cli.urlDispatcherEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 	cli.connectivityEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true),
 		uint32(networkmanager.ConnectedGlobal))
 	cli.systemImageInfo = siInfoRes
-	cli.postalServiceEndpoint = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
-	cli.setupPostalService()
+	d := new(dumbPostal)
+	cli.postalService = d
+	c.Assert(cli.startPostalService(), IsNil)
+
 	c.Assert(cli.initSession(), IsNil)
 
 	cli.session.BroadcastCh = make(chan *session.BroadcastNotification)
@@ -1073,13 +1069,6 @@
 	tick()
 	c.Check(cs.log.Captured(), Matches, "(?ms).*Session connected after 42 attempts$")
 
-	//  * actionsCh to the click handler/url dispatcher
-	aCh <- notifications.RawActionReply{ActionId: ACTION_ID_BROADCAST}
-	tick()
-	uargs := testibus.GetCallArgs(cli.urlDispatcherEndp)
-	c.Assert(uargs, HasLen, 1)
-	c.Check(uargs[0].Member, Equals, "DispatchURL")
-
 	// loop() should have connected:
 	//  * connCh to the connectivity checker
 	c.Check(cli.hasConnectivity, Equals, false)
@@ -1091,10 +1080,10 @@
 	c.Check(cli.hasConnectivity, Equals, false)
 
 	//  * session.BroadcastCh to the notifications handler
+	c.Check(d.bcastCount, Equals, 0)
 	cli.session.BroadcastCh <- positiveBroadcastNotification
 	tick()
-	nargs := testibus.GetCallArgs(cli.notificationsEndp)
-	c.Check(nargs, HasLen, 1)
+	c.Check(d.bcastCount, Equals, 1)
 
 	//  * session.ErrCh to the error handler
 	cli.session.ErrCh <- nil
@@ -1117,6 +1106,7 @@
 }
 
 func (cs *clientSuite) TestStart(c *C) {
+	c.Skip("no dbus")
 	if !cs.hasDbus() {
 		c.Skip("no dbus")
 	}
@@ -1132,7 +1122,7 @@
 	// no session,
 	c.Check(cli.session, IsNil)
 	// no bus,
-	c.Check(cli.notificationsEndp, IsNil)
+	c.Check(cli.systemImageEndp, IsNil)
 	// no nuthin'.
 
 	// so we start,
@@ -1147,7 +1137,7 @@
 	// and a session,
 	c.Check(cli.session, NotNil)
 	// and a bus,
-	c.Check(cli.notificationsEndp, NotNil)
+	c.Check(cli.systemImageEndp, NotNil)
 	// and a service,
 	c.Check(cli.pushService, NotNil)
 	// and everthying us just peachy!

=== modified file 'client/service/common.go'
--- client/service/common.go	2014-07-04 19:21:42 +0000
+++ client/service/common.go	2014-07-21 14:14:04 +0000
@@ -30,10 +30,11 @@
 )
 
 type DBusService struct {
-	lock  sync.RWMutex
-	state ServiceState
-	Log   logger.Logger
-	Bus   bus.Endpoint
+	lock             sync.RWMutex
+	state            ServiceState
+	installedChecker click.InstalledChecker
+	Log              logger.Logger
+	Bus              bus.Endpoint
 }
 
 // the service can be in a numnber of states
@@ -50,6 +51,7 @@
 	ErrAlreadyStarted = errors.New("already started")
 	ErrBadArgCount    = errors.New("wrong number of arguments")
 	ErrBadArgType     = errors.New("bad argument type")
+	ErrBadJSON        = errors.New("bad json data")
 	ErrBadAppId       = errors.New("package must be prefix of app id")
 )
 
@@ -105,17 +107,21 @@
 // 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) {
+func (svc *DBusService) grabDBusPackageAndAppId(path string, args []interface{}, numExtra int) (app *click.AppId, err error) {
 	if len(args) != 1+numExtra {
-		return "", "", ErrBadArgCount
+		return nil, ErrBadArgCount
 	}
-	appId, ok := args[0].(string)
+	id, 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 nil, ErrBadArgType
+	}
+	pkgname := string(nih.Unquote([]byte(path[strings.LastIndex(path, "/")+1:])))
+	app, err = click.ParseAndVerifyAppId(id, svc.installedChecker)
+	if err != nil {
+		return nil, ErrBadAppId
+	}
+	if !app.InPackage(pkgname) {
+		return nil, ErrBadAppId
 	}
 	return
 }

=== modified file 'client/service/common_test.go'
--- client/service/common_test.go	2014-07-04 19:21:42 +0000
+++ client/service/common_test.go	2014-07-21 14:14:04 +0000
@@ -25,17 +25,20 @@
 var _ = Suite(&commonSuite{})
 
 func (cs *commonSuite) TestGrabDBusPackageAndAppIdWorks(c *C) {
+	svc := new(DBusService)
 	aDBusPath := "/com/ubuntu/Postal/com_2eexample_2etest"
 	aPackage := "com.example.test"
 	anAppId := aPackage + "_test"
-	pkg, app, err := grabDBusPackageAndAppId(aDBusPath, []interface{}{anAppId}, 0)
+	app, err := svc.grabDBusPackageAndAppId(aDBusPath, []interface{}{anAppId}, 0)
 	c.Check(err, IsNil)
-	c.Check(pkg, Equals, aPackage)
-	c.Check(app, Equals, anAppId)
+	c.Check(app.Package, Equals, aPackage)
+	c.Check(app.Original(), Equals, anAppId)
 }
 
 func (cs *commonSuite) TestGrabDBusPackageAndAppIdFails(c *C) {
+	svc := new(DBusService)
 	aDBusPath := "/com/ubuntu/Postal/com_2eexample_2etest"
+	aDBusPath2 := "/com/ubuntu/Postal/com_2efoo_2ebar"
 	aPackage := "com.example.test"
 	anAppId := aPackage + "_test"
 
@@ -50,11 +53,11 @@
 		{aDBusPath, []interface{}{anAppId, anAppId}, 0, ErrBadArgCount},
 		{aDBusPath, []interface{}{1}, 0, ErrBadArgType},
 		{aDBusPath, []interface{}{aPackage}, 0, ErrBadAppId},
+		{aDBusPath2, []interface{}{anAppId}, 0, ErrBadAppId},
 	} {
 		comment := Commentf("iteration #%d", i)
-		pkg, app, err := grabDBusPackageAndAppId(s.path, s.args, s.numExtra)
+		app, err := svc.grabDBusPackageAndAppId(s.path, s.args, s.numExtra)
 		c.Check(err, Equals, s.errt, comment)
-		c.Check(pkg, Equals, "", comment)
-		c.Check(app, Equals, "", comment)
+		c.Check(app, IsNil, comment)
 	}
 }

=== added file 'client/service/mbox.go'
--- client/service/mbox.go	1970-01-01 00:00:00 +0000
+++ client/service/mbox.go	2014-07-21 14:14:04 +0000
@@ -0,0 +1,80 @@
+/*
+ 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 (
+	"encoding/json"
+)
+
+var mBoxMaxMessagesSize = 128 * 1024
+
+// mBox can hold a size-limited amount of notification messages for one application.
+type mBox struct {
+	evicted  int
+	curSize  int
+	messages []string
+	nids     []string
+}
+
+func (box *mBox) evictFor(sz int) {
+	evictedSize := 0
+	i := box.evicted
+	n := len(box.messages)
+	for evictedSize < sz && i < n {
+		evictedSize += len(box.messages[i])
+		box.messages[i] = ""
+		box.nids[i] = ""
+		box.evicted++
+		i++
+	}
+	box.curSize -= evictedSize
+}
+
+// Append appends a message with notification id to the mbox.
+func (box *mBox) Append(message json.RawMessage, nid string) {
+	sz := len(message)
+	if box.curSize+sz > mBoxMaxMessagesSize {
+		// make space
+		box.evictFor(sz)
+	}
+	n := len(box.messages)
+	evicted := box.evicted
+	if evicted > 0 {
+		if evicted == n {
+			// all evicted, just start from scratch
+			box.messages = box.messages[0:0]
+			box.nids = box.nids[0:0]
+			box.evicted = 0
+		} else if evicted >= cap(box.messages)/2 {
+			// amortize: do a copy only each cap/2 evicted
+			copy(box.messages, box.messages[box.evicted:])
+			kept := n - box.evicted
+			box.messages = box.messages[0:kept]
+			copy(box.nids, box.nids[box.evicted:])
+			box.nids = box.nids[0:kept]
+			box.evicted = 0
+		}
+	}
+	box.messages = append(box.messages, string(message))
+	box.nids = append(box.nids, nid)
+	box.curSize += sz
+}
+
+// AllMessages gets all messages from the mbox.
+func (box *mBox) AllMessages() []string {
+	return box.messages[box.evicted:]
+}

=== added file 'client/service/mbox_test.go'
--- client/service/mbox_test.go	1970-01-01 00:00:00 +0000
+++ client/service/mbox_test.go	2014-07-21 14:14:04 +0000
@@ -0,0 +1,132 @@
+/*
+ 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 (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	. "launchpad.net/gocheck"
+)
+
+type mBoxSuite struct {
+	prevMBoxMaxMessagesSize int
+}
+
+var _ = Suite(&mBoxSuite{})
+
+func (s *mBoxSuite) SetUpSuite(c *C) {
+	s.prevMBoxMaxMessagesSize = mBoxMaxMessagesSize
+	mBoxMaxMessagesSize = 100
+}
+
+func (s *mBoxSuite) TearDownSuite(c *C) {
+	mBoxMaxMessagesSize = s.prevMBoxMaxMessagesSize
+}
+
+func (s *mBoxSuite) TestAppend(c *C) {
+	mbox := &mBox{}
+	m1 := json.RawMessage(`{"m":1}`)
+	m2 := json.RawMessage(`{"m":2}`)
+	mbox.Append(m1, "n1")
+	mbox.Append(m2, "n2")
+	c.Check(mbox.messages, DeepEquals, []string{string(m1), string(m2)})
+	c.Check(mbox.nids, DeepEquals, []string{"n1", "n2"})
+}
+
+func (s *mBoxSuite) TestAllMessagesEmpty(c *C) {
+	mbox := &mBox{}
+	c.Check(mbox.AllMessages(), HasLen, 0)
+}
+
+func (s *mBoxSuite) TestAllMessages(c *C) {
+	mbox := &mBox{}
+	m1 := json.RawMessage(`{"m":1}`)
+	m2 := json.RawMessage(`{"m":2}`)
+	mbox.Append(m1, "n1")
+	mbox.Append(m2, "n2")
+	c.Check(mbox.AllMessages(), DeepEquals, []string{string(m1), string(m2)})
+}
+
+func blobMessage(n int, sz int) json.RawMessage {
+	return json.RawMessage(fmt.Sprintf(`{"n":%d,"b":"%s"}`, n, strings.Repeat("x", sz-14)))
+}
+
+func (s *mBoxSuite) TestAppendEvictSome(c *C) {
+	mbox := &mBox{}
+	m1 := blobMessage(1, 25)
+	m2 := blobMessage(2, 25)
+	m3 := blobMessage(3, 50)
+	mbox.Append(m1, "n1")
+	mbox.Append(m2, "n2")
+	mbox.Append(m3, "n3")
+	c.Check(mbox.curSize, Equals, 100)
+	c.Check(mbox.evicted, Equals, 0)
+	m4 := blobMessage(4, 23)
+	mbox.Append(m4, "n4")
+	c.Assert(mbox.evicted, Equals, 1)
+	c.Check(mbox.curSize, Equals, 25+50+23)
+	c.Check(mbox.AllMessages(), DeepEquals, []string{string(m2), string(m3), string(m4)})
+	c.Check(mbox.messages[:1], DeepEquals, []string{""})
+	c.Check(mbox.nids, DeepEquals, []string{"", "n2", "n3", "n4"})
+}
+
+func (s *mBoxSuite) TestAppendEvictSomeCopyOver(c *C) {
+	mbox := &mBox{}
+	m1 := blobMessage(1, 25)
+	m2 := blobMessage(2, 25)
+	m3 := blobMessage(3, 25)
+	m4 := blobMessage(4, 25)
+	mbox.Append(m1, "n1")
+	mbox.Append(m2, "n2")
+	mbox.Append(m3, "n3")
+	mbox.Append(m4, "n4")
+	c.Check(mbox.curSize, Equals, 100)
+	c.Check(mbox.evicted, Equals, 0)
+	m5 := blobMessage(5, 40)
+	mbox.Append(m5, "n5")
+	c.Assert(mbox.evicted, Equals, 0)
+	c.Check(mbox.curSize, Equals, 90)
+	c.Check(mbox.AllMessages(), DeepEquals, []string{string(m3), string(m4), string(m5)})
+	c.Check(mbox.nids, DeepEquals, []string{"n3", "n4", "n5"})
+	// do it again
+	m6 := blobMessage(6, 40)
+	mbox.Append(m6, "n6")
+	c.Assert(mbox.evicted, Equals, 0)
+	c.Check(mbox.curSize, Equals, 80)
+	c.Check(mbox.AllMessages(), DeepEquals, []string{string(m5), string(m6)})
+	c.Check(mbox.nids, DeepEquals, []string{"n5", "n6"})
+}
+
+func (s *mBoxSuite) TestAppendEvictEverything(c *C) {
+	mbox := &mBox{}
+	m1 := blobMessage(1, 25)
+	m2 := blobMessage(2, 25)
+	m3 := blobMessage(3, 50)
+	mbox.Append(m1, "n1")
+	mbox.Append(m2, "n2")
+	mbox.Append(m3, "n3")
+	c.Check(mbox.curSize, Equals, 100)
+	c.Check(mbox.evicted, Equals, 0)
+	m4 := blobMessage(4, 90)
+	mbox.Append(m4, "n4")
+	c.Assert(mbox.evicted, Equals, 0)
+	c.Check(mbox.curSize, Equals, 90)
+	c.Check(mbox.AllMessages(), DeepEquals, []string{string(m4)})
+	c.Check(mbox.nids, DeepEquals, []string{"n4"})
+}

=== modified file 'client/service/postal.go'
--- client/service/postal.go	2014-07-06 20:48:50 +0000
+++ client/service/postal.go	2014-07-21 14:14:04 +0000
@@ -17,6 +17,8 @@
 package service
 
 import (
+	"encoding/json"
+	"os"
 	"sync"
 
 	"code.google.com/p/go-uuid/uuid"
@@ -25,24 +27,43 @@
 	"launchpad.net/ubuntu-push/bus/emblemcounter"
 	"launchpad.net/ubuntu-push/bus/haptic"
 	"launchpad.net/ubuntu-push/bus/notifications"
+	"launchpad.net/ubuntu-push/bus/urldispatcher"
+	"launchpad.net/ubuntu-push/bus/windowstack"
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/messaging"
+	"launchpad.net/ubuntu-push/messaging/reply"
 	"launchpad.net/ubuntu-push/nih"
 	"launchpad.net/ubuntu-push/sounds"
 	"launchpad.net/ubuntu-push/util"
 )
 
+type messageHandler func(*click.AppId, string, *launch_helper.HelperOutput) error
+
 // PostalService is the dbus api
 type PostalService struct {
 	DBusService
-	mbox              map[string][]string
-	msgHandler        func(string, string, *launch_helper.HelperOutput) error
-	HelperLauncher    launch_helper.HelperLauncher
-	messagingMenu     *messaging.MessagingMenu
-	emblemcounterEndp bus.Endpoint
-	hapticEndp        bus.Endpoint
-	notificationsEndp bus.Endpoint
+	mbox          map[string]*mBox
+	msgHandler    messageHandler
+	launchers     map[string]launch_helper.HelperLauncher
+	HelperPool    launch_helper.HelperPool
+	messagingMenu *messaging.MessagingMenu
+	// the endpoints are only exposed for testing from client
+	// XXX: uncouple some more so this isn't necessary
+	EmblemCounterEndp bus.Endpoint
+	HapticEndp        bus.Endpoint
+	NotificationsEndp bus.Endpoint
+	URLDispatcherEndp bus.Endpoint
+	WindowStackEndp   bus.Endpoint
+	// presenters:
+	emblemCounter *emblemcounter.EmblemCounter
+	haptic        *haptic.Haptic
+	notifications *notifications.RawNotifications
+	sound         *sounds.Sound
+	// the url dispatcher, used for stuff.
+	urlDispatcher urldispatcher.URLDispatcher
+	windowStack   *windowstack.WindowStack
 }
 
 var (
@@ -55,33 +76,34 @@
 
 var (
 	SystemUpdateUrl  = "settings:///system/system-update"
-	ACTION_ID_PREFIX = "ubuntu-push-client::"
-	ACTION_ID_SUFFIX = "::0"
+	useTrivialHelper = os.Getenv("UBUNTU_PUSH_USE_TRIVIAL_HELPER") != ""
 )
 
 // NewPostalService() builds a new service and returns it.
-func NewPostalService(busEndp bus.Endpoint, notificationsEndp bus.Endpoint, emblemcounterEndp bus.Endpoint, hapticEndp bus.Endpoint, log logger.Logger) *PostalService {
+func NewPostalService(installedChecker click.InstalledChecker, 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.Bus = bus.SessionBus.Endpoint(PostalServiceBusAddress, log)
+	svc.installedChecker = installedChecker
+	svc.NotificationsEndp = bus.SessionBus.Endpoint(notifications.BusAddress, log)
+	svc.EmblemCounterEndp = bus.SessionBus.Endpoint(emblemcounter.BusAddress, log)
+	svc.HapticEndp = bus.SessionBus.Endpoint(haptic.BusAddress, log)
+	svc.URLDispatcherEndp = bus.SessionBus.Endpoint(urldispatcher.BusAddress, log)
+	svc.WindowStackEndp = bus.SessionBus.Endpoint(windowstack.BusAddress, log)
 	svc.msgHandler = svc.messageHandler
+	svc.launchers = launch_helper.DefaultLaunchers(log)
 	return svc
 }
 
 // SetMessageHandler() sets the message-handling callback
-func (svc *PostalService) SetMessageHandler(callback func(string, string, *launch_helper.HelperOutput) error) {
+func (svc *PostalService) SetMessageHandler(callback messageHandler) {
 	svc.lock.RLock()
 	defer svc.lock.RUnlock()
 	svc.msgHandler = callback
 }
 
 // GetMessageHandler() returns the (possibly nil) messaging handler callback
-func (svc *PostalService) GetMessageHandler() func(string, string, *launch_helper.HelperOutput) error {
+func (svc *PostalService) GetMessageHandler() messageHandler {
 	svc.lock.RLock()
 	defer svc.lock.RUnlock()
 	return svc.msgHandler
@@ -89,34 +111,106 @@
 
 // Start() dials the bus, grab the name, and listens for method calls.
 func (svc *PostalService) Start() error {
-	return svc.DBusService.Start(bus.DispatchMap{
-		"Messages": svc.notifications,
-		"Post":     svc.inject,
+	err := svc.DBusService.Start(bus.DispatchMap{
+		"PopAll": svc.popAll,
+		"Post":   svc.post,
 	}, PostalServiceBusAddress)
-}
-
-func (svc *PostalService) TakeTheBus() (<-chan notifications.RawActionReply, error) {
+	if err != nil {
+		return err
+	}
+	actionsCh, err := svc.takeTheBus()
+	if err != nil {
+		return err
+	}
+	svc.urlDispatcher = urldispatcher.New(svc.URLDispatcherEndp, svc.Log)
+	svc.notifications = notifications.Raw(svc.NotificationsEndp, svc.Log)
+	svc.emblemCounter = emblemcounter.New(svc.EmblemCounterEndp, svc.Log)
+	svc.haptic = haptic.New(svc.HapticEndp, svc.Log)
+	svc.sound = sounds.New(svc.Log)
+	svc.messagingMenu = messaging.New(svc.Log)
+	if useTrivialHelper {
+		svc.HelperPool = launch_helper.NewTrivialHelperPool(svc.Log)
+	} else {
+		svc.HelperPool = launch_helper.NewHelperPool(svc.launchers, svc.Log)
+	}
+	svc.windowStack = windowstack.New(svc.WindowStackEndp, svc.Log)
+
+	go svc.consumeHelperResults(svc.HelperPool.Start())
+	go svc.handleActions(actionsCh, svc.messagingMenu.Ch)
+	return nil
+}
+
+// xxx Stop() closing channels and helper launcher
+
+// handleactions loops on the actions channels waiting for actions and handling them
+func (svc *PostalService) handleActions(actionsCh <-chan *notifications.RawAction, mmuActionsCh <-chan *reply.MMActionReply) {
+Handle:
+	for {
+		select {
+		case action, ok := <-actionsCh:
+			if !ok {
+				break Handle
+			}
+			if action == nil {
+				svc.Log.Debugf("handleActions got nil action; ignoring")
+			} else {
+				url := action.Action
+				// this ignores the error (it's been logged already)
+				svc.urlDispatcher.DispatchURL(url)
+			}
+		case mmuAction, ok := <-mmuActionsCh:
+			if !ok {
+				break Handle
+			}
+			if mmuAction == nil {
+				svc.Log.Debugf("handleActions (MMU) got nil action; ignoring")
+			} else {
+				svc.Log.Debugf("handleActions (MMU) got: %v", mmuAction)
+				url := mmuAction.Action
+				// remove the notification from the messagingmenu map
+				svc.messagingMenu.RemoveNotification(mmuAction.Notification)
+				// this ignores the error (it's been logged already)
+				svc.urlDispatcher.DispatchURL(url)
+			}
+
+		}
+	}
+}
+
+func (svc *PostalService) takeTheBus() (<-chan *notifications.RawAction, error) {
+	endps := []struct {
+		name string
+		endp bus.Endpoint
+	}{
+		{"notifications", svc.NotificationsEndp},
+		{"emblemcounter", svc.EmblemCounterEndp},
+		{"haptic", svc.HapticEndp},
+		{"urldispatcher", svc.URLDispatcherEndp},
+		{"windowstack", svc.WindowStackEndp},
+	}
+	for _, endp := range endps {
+		if endp.endp == nil {
+			svc.Log.Errorf("endpoint for %s is nil", endp.name)
+			return nil, ErrNotConfigured
+		}
+	}
+
 	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) {
+		go func(name string, endp bus.Endpoint) {
 			util.NewAutoRedialer(endp).Redial()
+			svc.Log.Debugf("%s dialed in", name)
 			wg.Done()
-		}(endp)
+		}(endp.name, endp.endp)
 	}
 	wg.Wait()
-	actionsCh, err := notifications.Raw(svc.notificationsEndp, svc.Log).WatchActions()
 
-	return actionsCh, err
+	return notifications.Raw(svc.NotificationsEndp, svc.Log).WatchActions()
 }
 
-func (svc *PostalService) notifications(path string, args, _ []interface{}) ([]interface{}, error) {
-	_, appId, err := grabDBusPackageAndAppId(path, args, 0)
+func (svc *PostalService) popAll(path string, args, _ []interface{}) ([]interface{}, error) {
+	app, err := svc.grabDBusPackageAndAppId(path, args, 0)
 	if err != nil {
 		return nil, err
 	}
@@ -127,7 +221,12 @@
 	if svc.mbox == nil {
 		return []interface{}{[]string(nil)}, nil
 	}
-	msgs := svc.mbox[appId]
+	appId := app.Original()
+	box, ok := svc.mbox[appId]
+	if !ok {
+		return []interface{}{[]string(nil)}, nil
+	}
+	msgs := box.AllMessages()
 	delete(svc.mbox, appId)
 
 	return []interface{}{msgs}, nil
@@ -135,8 +234,8 @@
 
 var newNid = uuid.New
 
-func (svc *PostalService) inject(path string, args, _ []interface{}) ([]interface{}, error) {
-	pkg, appId, err := grabDBusPackageAndAppId(path, args, 1)
+func (svc *PostalService) post(path string, args, _ []interface{}) ([]interface{}, error) {
+	app, err := svc.grabDBusPackageAndAppId(path, args, 1)
 	if err != nil {
 		return nil, err
 	}
@@ -144,55 +243,83 @@
 	if !ok {
 		return nil, ErrBadArgType
 	}
+	var dummy interface{}
+	rawJSON := json.RawMessage(notif)
+	err = json.Unmarshal(rawJSON, &dummy)
+	if err != nil {
+		return nil, ErrBadJSON
+	}
 
 	nid := newNid()
 
-	return nil, svc.Inject(pkg, appId, nid, notif)
+	return nil, svc.Post(app, nid, rawJSON)
 }
 
-// Inject() signals to an application over dbus that a notification
+// Post() signals to an application over dbus that a notification
 // has arrived.
-func (svc *PostalService) Inject(pkgname string, appname string, nid string, notif string) error {
+func (svc *PostalService) Post(app *click.AppId, nid string, payload json.RawMessage) error {
+	arg := launch_helper.HelperInput{
+		App:            app,
+		NotificationId: nid,
+		Payload:        payload,
+	}
+	var kind string
+	if app.Click {
+		kind = "click"
+	} else {
+		kind = "legacy"
+	}
+	svc.HelperPool.Run(kind, &arg)
+	return nil
+}
+
+func (svc *PostalService) consumeHelperResults(ch chan *launch_helper.HelperResult) {
+	for res := range ch {
+		svc.handleHelperResult(res)
+	}
+}
+
+func (svc *PostalService) handleHelperResult(res *launch_helper.HelperResult) {
 	svc.lock.Lock()
 	defer svc.lock.Unlock()
 	if svc.mbox == nil {
-		svc.mbox = make(map[string][]string)
-	}
-	output := svc.HelperLauncher.Run(appname, []byte(notif))
-	// XXX also track the nid in the mbox
-	svc.mbox[appname] = append(svc.mbox[appname], string(output.Message))
+		svc.mbox = make(map[string]*mBox)
+	}
+
+	app := res.Input.App
+	nid := res.Input.NotificationId
+	output := res.HelperOutput
+
+	appId := app.Original()
+	box, ok := svc.mbox[appId]
+	if !ok {
+		box = new(mBox)
+		svc.mbox[appId] = box
+	}
+	box.Append(output.Message, nid)
 
 	if svc.msgHandler != nil {
-		err := svc.msgHandler(appname, nid, output)
+		err := svc.msgHandler(app, nid, &output)
 		if err != nil {
 			svc.DBusService.Log.Errorf("msgHandler returned %v", err)
-			return err
+			return
 		}
 		svc.DBusService.Log.Debugf("call to msgHandler successful")
 	}
 
-	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) 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)
+	svc.Bus.Signal("Post", "/"+string(nih.Quote([]byte(app.Package))), []interface{}{appId})
+}
+
+func (svc *PostalService) messageHandler(app *click.AppId, nid string, output *launch_helper.HelperOutput) error {
+	if !svc.windowStack.IsAppFocused(app) {
+		svc.messagingMenu.Present(app, nid, output.Notification)
+		_, err := svc.notifications.Present(app, nid, output.Notification)
+		svc.emblemCounter.Present(app, nid, output.Notification)
+		svc.haptic.Present(app, nid, output.Notification)
+		svc.sound.Present(app, nid, output.Notification)
+		return err
+	} else {
+		svc.Log.Debugf("Notification skipped because app is focused.")
+		return nil
+	}
 }

=== modified file 'client/service/postal_test.go'
--- client/service/postal_test.go	2014-07-07 12:44:51 +0000
+++ client/service/postal_test.go	2014-07-21 14:14:04 +0000
@@ -17,135 +17,341 @@
 package service
 
 import (
+	"encoding/json"
 	"errors"
+	"io/ioutil"
+	"os"
+	"path/filepath"
 	"sort"
+	"time"
+
+	"code.google.com/p/go-uuid/uuid"
 
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/bus/notifications"
 	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/bus/windowstack"
+	"launchpad.net/ubuntu-push/click"
+	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	"launchpad.net/ubuntu-push/launch_helper"
+	"launchpad.net/ubuntu-push/messaging/reply"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
 )
 
+// takeNext takes a value from given channel with a 5s timeout
+func takeNextBool(ch <-chan bool) bool {
+	select {
+	case <-time.After(5 * time.Second):
+		panic("channel stuck: too long waiting")
+	case v := <-ch:
+		return v
+	}
+}
+
+// takeNextBytes takes a value from given channel with a 5s timeout
+func takeNextBytes(ch <-chan []byte) []byte {
+	select {
+	case <-time.After(5 * time.Second):
+		panic("channel stuck: too long waiting")
+	case v := <-ch:
+		return v
+	}
+}
+
+// takeNextHelperOutput takes a value from given channel with a 5s timeout
+func takeNextHelperOutput(ch <-chan *launch_helper.HelperOutput) *launch_helper.HelperOutput {
+	select {
+	case <-time.After(5 * time.Second):
+		panic("channel stuck: too long waiting")
+	case v := <-ch:
+		return v
+	}
+}
+
+func takeNextError(ch <-chan error) error {
+	select {
+	case <-time.After(5 * time.Second):
+		panic("channel stuck: too long waiting")
+	case v := <-ch:
+		return v
+	}
+}
+
+func installTickMessageHandler(svc *PostalService) chan error {
+	ch := make(chan error)
+	msgHandler := svc.GetMessageHandler()
+	svc.SetMessageHandler(func(app *click.AppId, nid string, output *launch_helper.HelperOutput) error {
+		var err error
+		if msgHandler != nil {
+			err = msgHandler(app, nid, output)
+		}
+		ch <- err
+		return err
+	})
+	return ch
+}
+
+type fakeHelperLauncher struct {
+	i    int
+	ch   chan []byte
+	done func(string)
+}
+
+func (fhl *fakeHelperLauncher) InstallObserver(done func(string)) error {
+	fhl.done = done
+	return nil
+}
+func (fhl *fakeHelperLauncher) RemoveObserver() error  { return nil }
+func (fhl *fakeHelperLauncher) Stop(_, _ string) error { return nil }
+func (fhl *fakeHelperLauncher) HelperInfo(app *click.AppId) (string, string) {
+	if app.Click {
+		return "helpId", "bar"
+	} else {
+		return "", "lhex"
+	}
+}
+func (fhl *fakeHelperLauncher) Launch(_, _, f1, f2 string) (string, error) {
+	dat, err := ioutil.ReadFile(f1)
+	if err != nil {
+		return "", err
+	}
+	err = ioutil.WriteFile(f2, dat, os.ModeTemporary)
+	if err != nil {
+		return "", err
+	}
+
+	id := []string{"0", "1", "2"}[fhl.i]
+	fhl.i++
+
+	fhl.ch <- dat
+
+	return id, nil
+}
+
 type postalSuite struct {
-	log        *helpers.TestLogger
-	bus        bus.Endpoint
-	notifBus   bus.Endpoint
-	counterBus bus.Endpoint
-	hapticBus  bus.Endpoint
-}
-
-var _ = Suite(&postalSuite{})
-
-func (ss *postalSuite) SetUpTest(c *C) {
-	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.counterBus, ss.hapticBus, ss.log)
+	log          *helpers.TestLogger
+	bus          bus.Endpoint
+	notifBus     bus.Endpoint
+	counterBus   bus.Endpoint
+	hapticBus    bus.Endpoint
+	urlDispBus   bus.Endpoint
+	winStackBus  bus.Endpoint
+	fakeLauncher *fakeHelperLauncher
+	getTempDir   func(string) (string, error)
+}
+
+type ualPostalSuite struct {
+	postalSuite
+}
+
+type trivialPostalSuite struct {
+	postalSuite
+}
+
+var _ = Suite(&ualPostalSuite{})
+var _ = Suite(&trivialPostalSuite{})
+
+func (ps *postalSuite) SetUpTest(c *C) {
+	ps.log = helpers.NewTestLogger(c, "debug")
+	ps.bus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
+	ps.notifBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
+	ps.counterBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
+	ps.hapticBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
+	ps.urlDispBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
+	ps.winStackBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []windowstack.WindowsInfo{})
+	ps.fakeLauncher = &fakeHelperLauncher{ch: make(chan []byte)}
+
+	ps.getTempDir = launch_helper.GetTempDir
+	d := c.MkDir()
+	launch_helper.GetTempDir = func(pkgName string) (string, error) {
+		tmpDir := filepath.Join(d, pkgName)
+		return tmpDir, os.MkdirAll(tmpDir, 0700)
+	}
+}
+
+func (ps *postalSuite) TearDownTest(c *C) {
+	launch_helper.GetTempDir = ps.getTempDir
+}
+
+func (ts *trivialPostalSuite) SetUpTest(c *C) {
+	ts.postalSuite.SetUpTest(c)
+	useTrivialHelper = true
+}
+
+func (ts *trivialPostalSuite) TearDownTest(c *C) {
+	ts.postalSuite.TearDownTest(c)
+	useTrivialHelper = false
+}
+
+func (ps *postalSuite) replaceBuses(pst *PostalService) *PostalService {
+	pst.Bus = ps.bus
+	pst.NotificationsEndp = ps.notifBus
+	pst.EmblemCounterEndp = ps.counterBus
+	pst.HapticEndp = ps.hapticBus
+	pst.URLDispatcherEndp = ps.urlDispBus
+	pst.WindowStackEndp = ps.winStackBus
+	pst.launchers = map[string]launch_helper.HelperLauncher{}
+	return pst
+}
+
+func (ps *postalSuite) TestStart(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
 	c.Check(svc.IsRunning(), Equals, false)
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.IsRunning(), Equals, true)
 	svc.Stop()
 }
 
-func (ss *postalSuite) TestStartTwice(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
+func (ps *postalSuite) TestStartTwice(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.Start(), Equals, ErrAlreadyStarted)
 	svc.Stop()
 }
 
-func (ss *postalSuite) TestStartNoLog(c *C) {
-	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.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.counterBus, ss.hapticBus, ss.log)
-	_, err := svc.TakeTheBus()
+func (ps *postalSuite) TestStartNoLog(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, nil))
+	c.Check(svc.Start(), Equals, ErrNotConfigured)
+}
+
+func (ps *postalSuite) TestStartNoBus(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.Bus = nil
+	c.Check(svc.Start(), Equals, ErrNotConfigured)
+
+	svc = ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.NotificationsEndp = nil
+	c.Check(svc.Start(), Equals, ErrNotConfigured)
+}
+
+func (ps *postalSuite) TestTakeTheBusFail(c *C) {
+	nEndp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), condition.Work(false))
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.NotificationsEndp = nEndp
+	_, err := svc.takeTheBus()
 	c.Check(err, NotNil)
 }
 
-func (ss *postalSuite) TestTakeTheBustOk(c *C) {
+func (ps *postalSuite) TestTakeTheBusOk(c *C) {
 	nEndp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), condition.Work(true), []interface{}{uint32(1), "hello"})
-	svc := NewPostalService(ss.bus, nEndp, ss.counterBus, ss.hapticBus, ss.log)
-	_, err := svc.TakeTheBus()
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.NotificationsEndp = nEndp
+	_, 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.counterBus, ss.hapticBus, ss.log)
+func (ps *postalSuite) TestStartFailsOnBusDialFailure(c *C) {
+	// XXX actually, we probably want to autoredial this
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.Bus = testibus.NewTestingEndpoint(condition.Work(false), nil)
 	c.Check(svc.Start(), ErrorMatches, `.*(?i)cond said no.*`)
 	svc.Stop()
 }
 
-func (ss *postalSuite) TestStartGrabsName(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
+func (ps *postalSuite) TestStartGrabsName(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
 	c.Assert(svc.Start(), IsNil)
-	callArgs := testibus.GetCallArgs(ss.bus)
+	callArgs := testibus.GetCallArgs(ps.bus)
 	defer svc.Stop()
 	c.Assert(callArgs, NotNil)
 	c.Check(callArgs[0].Member, Equals, "::GrabName")
 }
 
-func (ss *postalSuite) TestStopClosesBus(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
+func (ps *postalSuite) TestStopClosesBus(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
 	c.Assert(svc.Start(), IsNil)
 	svc.Stop()
-	callArgs := testibus.GetCallArgs(ss.bus)
+	callArgs := testibus.GetCallArgs(ps.bus)
 	c.Assert(callArgs, NotNil)
 	c.Check(callArgs[len(callArgs)-1].Member, Equals, "::Close")
 }
 
 //
-// Injection tests
-
-func (ss *postalSuite) TestInjectWorks(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
-	svc.msgHandler = nil
-	rvs, err := svc.inject(aPackageOnBus, []interface{}{anAppId, "world"}, nil)
-	c.Assert(err, IsNil)
-	c.Check(rvs, IsNil)
-	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[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{}{"Post", aPackageOnBus, []interface{}{anAppId}})
-	c.Check(callArgs[1], DeepEquals, callArgs[0])
-}
-
-func (ss *postalSuite) TestInjectFailsIfInjectFails(c *C) {
+// Post() tests
+
+func (ps *postalSuite) TestPostWorks(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.msgHandler = nil
+	ch := installTickMessageHandler(svc)
+	fakeLauncher2 := &fakeHelperLauncher{ch: make(chan []byte)}
+	svc.launchers = map[string]launch_helper.HelperLauncher{
+		"click":  ps.fakeLauncher,
+		"legacy": fakeLauncher2,
+	}
+	c.Assert(svc.Start(), IsNil)
+	rvs, err := svc.post(aPackageOnBus, []interface{}{anAppId, `{"message":{"world":1}}`}, nil)
+	c.Assert(err, IsNil)
+	c.Check(rvs, IsNil)
+	rvs, err = svc.post(aPackageOnBus, []interface{}{anAppId, `{"message":{"moon":1}}`}, nil)
+	c.Assert(err, IsNil)
+	c.Check(rvs, IsNil)
+	rvs, err = svc.post("_", []interface{}{"_classic-app", `{"message":{"mars":42}}`}, nil)
+	c.Assert(err, IsNil)
+	c.Check(rvs, IsNil)
+
+	if ps.fakeLauncher.done != nil {
+		// wait for the two posts to "launch"
+		takeNextBytes(ps.fakeLauncher.ch)
+		takeNextBytes(ps.fakeLauncher.ch)
+		takeNextBytes(fakeLauncher2.ch)
+
+		go ps.fakeLauncher.done("0") // OneDone
+		go ps.fakeLauncher.done("1") // OneDone
+		go fakeLauncher2.done("0")
+	}
+
+	c.Check(takeNextError(ch), IsNil) // one,
+	c.Check(takeNextError(ch), IsNil) // two,
+	c.Check(takeNextError(ch), IsNil) // three posts
+	c.Assert(svc.mbox, HasLen, 2)
+	box, ok := svc.mbox[anAppId]
+	c.Check(ok, Equals, true)
+	msgs := box.AllMessages()
+	c.Assert(msgs, HasLen, 2)
+	c.Check(msgs[0], Equals, `{"world":1}`)
+	c.Check(msgs[1], Equals, `{"moon":1}`)
+	box, ok = svc.mbox["_classic-app"]
+	c.Assert(ok, Equals, true)
+	msgs = box.AllMessages()
+	c.Assert(msgs, HasLen, 1)
+	c.Check(msgs[0], Equals, `{"mars":42}`)
+}
+
+func (ps *postalSuite) TestPostSignal(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.msgHandler = nil
+
+	hInp := &launch_helper.HelperInput{
+		App: clickhelp.MustParseAppId(anAppId),
+	}
+	res := &launch_helper.HelperResult{Input: hInp}
+
+	svc.handleHelperResult(res)
+
+	// and check it fired the right signal
+	callArgs := testibus.GetCallArgs(ps.bus)
+	l := len(callArgs)
+	if l < 1 {
+		c.Fatal("not enough elements in resposne from GetCallArgs")
+	}
+	c.Check(callArgs[l-1].Member, Equals, "::Signal")
+	c.Check(callArgs[l-1].Args, DeepEquals, []interface{}{"Post", aPackageOnBus, []interface{}{anAppId}})
+}
+
+func (ps *postalSuite) TestPostFailsIfPostFails(c *C) {
 	bus := testibus.NewTestingEndpoint(condition.Work(true),
 		condition.Work(false))
-	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)
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.Bus = bus
+	svc.SetMessageHandler(func(*click.AppId, string, *launch_helper.HelperOutput) error { return errors.New("fail") })
+	_, err := svc.post("/hello", []interface{}{"xyzzy"}, nil)
 	c.Check(err, NotNil)
 }
 
-func (ss *postalSuite) TestInjectFailsIfBadArgs(c *C) {
+func (ps *postalSuite) TestPostFailsIfBadArgs(c *C) {
 	for i, s := range []struct {
 		args []interface{}
 		errt error
@@ -154,69 +360,119 @@
 		{[]interface{}{}, ErrBadArgCount},
 		{[]interface{}{1}, ErrBadArgCount},
 		{[]interface{}{anAppId, 1}, ErrBadArgType},
+		{[]interface{}{anAppId, "zoom"}, ErrBadJSON},
 		{[]interface{}{1, "hello"}, ErrBadArgType},
 		{[]interface{}{1, 2, 3}, ErrBadArgCount},
 		{[]interface{}{"bar", "hello"}, ErrBadAppId},
 	} {
-		reg, err := new(PostalService).inject(aPackageOnBus, s.args, nil)
+		reg, err := new(PostalService).post(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)
+// Post (Broadcast) tests
+
+func (ps *postalSuite) TestPostBroadcast(c *C) {
+
+	bus := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+
+	svc.NotificationsEndp = bus
+	svc.launchers = map[string]launch_helper.HelperLauncher{
+		"legacy": ps.fakeLauncher,
+	}
+	c.Assert(svc.Start(), IsNil)
+
+	msgId := uuid.New()
+	svc.SetMessageHandler(func(app *click.AppId, nid string, output *launch_helper.HelperOutput) error {
+		expectedAppId, _ := click.ParseAppId("_ubuntu-system-settings")
+		c.Check(app, DeepEquals, expectedAppId)
+		c.Check(nid, Equals, msgId)
+		return nil
+	})
+	decoded := map[string]interface{}{
+		"daily/mako": []interface{}{float64(102), "tubular"},
+	}
+	// marshal decoded  to json
+	payload, _ := json.Marshal(decoded)
+	appId, _ := click.ParseAppId("_ubuntu-system-settings")
+	err := svc.Post(appId, msgId, payload)
+	c.Assert(err, IsNil)
+
+	if ps.fakeLauncher.done != nil {
+		inputData := takeNextBytes(ps.fakeLauncher.ch)
+		expectedData, _ := json.Marshal(decoded)
+		c.Check(inputData, DeepEquals, expectedData)
+		go ps.fakeLauncher.done("0") // OneDone
+	}
 }
 
-func (ss *postalSuite) TestInjectBroadcastFails(c *C) {
+func (ps *postalSuite) TestPostBroadcastDoesNotFail(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)
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.launchers = map[string]launch_helper.HelperLauncher{
+		"legacy": ps.fakeLauncher,
+	}
+	c.Assert(svc.Start(), IsNil)
+	svc.NotificationsEndp = bus
+	svc.SetMessageHandler(func(*click.AppId, string, *launch_helper.HelperOutput) error {
+		ps.log.Debugf("about to fail")
+		return errors.New("fail")
+	})
+	ch := installTickMessageHandler(svc)
+	decoded := map[string]interface{}{
+		"daily/mako": []interface{}{float64(102), "tubular"},
+	}
+	// marshal decoded  to json
+	payload, _ := json.Marshal(decoded)
+	appId, _ := click.ParseAppId("_ubuntu-system-settings")
+	msgId := uuid.New()
+	err := svc.Post(appId, msgId, payload)
+	c.Assert(err, IsNil)
+
+	if ps.fakeLauncher.done != nil {
+		takeNextBytes(ps.fakeLauncher.ch)
+		go ps.fakeLauncher.done("0") // OneDone
+	}
+
+	c.Check(takeNextError(ch), NotNil) // the messagehandler failed
+	c.Check(err, IsNil)                // but broadcast was oblivious
+	c.Check(ps.log.Captured(), Matches, `(?sm).*about to fail$`)
 }
 
 //
 // Notifications tests
-func (ss *postalSuite) TestNotificationsWorks(c *C) {
-	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)
-	c.Check(nots[0], HasLen, 0)
-	if svc.mbox == nil {
-		svc.mbox = make(map[string][]string)
-	}
-	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)
-	c.Check(nots[0], DeepEquals, []string{"this", "thing"})
+func (ps *postalSuite) TestNotificationsWorks(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	nots, err := svc.popAll(aPackageOnBus, []interface{}{anAppId}, nil)
+	c.Assert(err, IsNil)
+	c.Assert(nots, NotNil)
+	c.Assert(nots, HasLen, 1)
+	c.Check(nots[0], HasLen, 0)
+	c.Assert(svc.mbox, IsNil)
+	svc.mbox = make(map[string]*mBox)
+	nots, err = svc.popAll(aPackageOnBus, []interface{}{anAppId}, nil)
+	c.Assert(err, IsNil)
+	c.Assert(nots, NotNil)
+	c.Assert(nots, HasLen, 1)
+	c.Check(nots[0], HasLen, 0)
+	box := new(mBox)
+	svc.mbox[anAppId] = box
+	m1 := json.RawMessage(`"m1"`)
+	m2 := json.RawMessage(`"m2"`)
+	box.Append(m1, "n1")
+	box.Append(m2, "n2")
+	nots, err = svc.popAll(aPackageOnBus, []interface{}{anAppId}, nil)
+	c.Assert(err, IsNil)
+	c.Assert(nots, NotNil)
+	c.Assert(nots, HasLen, 1)
+	c.Check(nots[0], DeepEquals, []string{string(m1), string(m2)})
 }
 
-func (ss *postalSuite) TestNotificationsFailsIfBadArgs(c *C) {
+func (ps *postalSuite) TestNotificationsFailsIfBadArgs(c *C) {
 	for i, s := range []struct {
 		args []interface{}
 		errt error
@@ -226,52 +482,77 @@
 		{[]interface{}{1}, ErrBadArgType},
 		{[]interface{}{"potato"}, ErrBadAppId},
 	} {
-		reg, err := new(PostalService).notifications(aPackageOnBus, s.args, nil)
+		reg, err := new(PostalService).popAll(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) {
+func (ps *postalSuite) TestMessageHandlerPublicAPI(c *C) {
 	svc := new(PostalService)
 	c.Assert(svc.msgHandler, IsNil)
 	var ext = &launch_helper.HelperOutput{}
 	e := errors.New("Hello")
-	f := func(app string, nid string, s *launch_helper.HelperOutput) error { ext = s; return e }
+	f := func(_ *click.AppId, _ string, s *launch_helper.HelperOutput) error { ext = s; return e }
 	c.Check(svc.GetMessageHandler(), IsNil)
 	svc.SetMessageHandler(f)
 	c.Check(svc.GetMessageHandler(), NotNil)
 	hOutput := &launch_helper.HelperOutput{[]byte("37"), nil}
-	c.Check(svc.msgHandler("", "", hOutput), Equals, e)
+	c.Check(svc.msgHandler(nil, "", hOutput), Equals, e)
 	c.Check(ext, DeepEquals, hOutput)
 }
 
-func (ss *postalSuite) TestInjectCallsMessageHandler(c *C) {
-	var ext = &launch_helper.HelperOutput{}
-	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 }
+func (ps *postalSuite) TestPostCallsMessageHandler(c *C) {
+	ch := make(chan *launch_helper.HelperOutput)
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.launchers = map[string]launch_helper.HelperLauncher{
+		"click": ps.fakeLauncher,
+	}
+	c.Assert(svc.Start(), IsNil)
+	// check the message handler gets called
+	f := func(_ *click.AppId, _ string, s *launch_helper.HelperOutput) error { ch <- s; return nil }
 	svc.SetMessageHandler(f)
-	c.Check(svc.Inject("pkg", "app", "thing", "{}"), IsNil)
-	c.Check(ext, DeepEquals, &launch_helper.HelperOutput{})
+	c.Check(svc.Post(&click.AppId{Click: true}, "thing", json.RawMessage("{}")), IsNil)
+
+	if ps.fakeLauncher.done != nil {
+		takeNextBytes(ps.fakeLauncher.ch)
+
+		go ps.fakeLauncher.done("0") // OneDone
+	}
+
+	c.Check(takeNextHelperOutput(ch), DeepEquals, &launch_helper.HelperOutput{})
 	err := errors.New("ouch")
-	svc.SetMessageHandler(func(string, string, *launch_helper.HelperOutput) error { return err })
-	c.Check(svc.Inject("pkg", "app", "", "{}"), Equals, err)
+	svc.SetMessageHandler(func(*click.AppId, string, *launch_helper.HelperOutput) error { return err })
+	// but the error doesn't bubble out
+	c.Check(svc.Post(&click.AppId{}, "", json.RawMessage("{}")), IsNil)
 }
 
-func (ss *postalSuite) TestMessageHandlerPresents(c *C) {
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
-	svc := NewPostalService(endp, endp, endp, endp, ss.log)
+func (ps *postalSuite) TestMessageHandlerPresents(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(1))
+	svc := NewPostalService(nil, ps.log)
+	svc.Bus = endp
+	svc.EmblemCounterEndp = endp
+	svc.HapticEndp = endp
+	svc.NotificationsEndp = endp
+	svc.URLDispatcherEndp = ps.urlDispBus
+	svc.WindowStackEndp = ps.winStackBus
+	svc.launchers = map[string]launch_helper.HelperLauncher{}
+	c.Assert(svc.Start(), IsNil)
+
 	// 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)
+	err := svc.messageHandler(&click.AppId{}, "", output)
 	c.Assert(err, IsNil)
 	args := testibus.GetCallArgs(endp)
-	c.Assert(args, HasLen, 4)
-	mm := make([]string, len(args))
-	for i, m := range args {
+	l := len(args)
+	if l < 4 {
+		c.Fatal("not enough elements in resposne from GetCallArgs")
+	}
+	mm := make([]string, 4)
+	for i, m := range args[l-4:] {
 		mm[i] = m.Member
 	}
 	sort.Strings(mm)
@@ -279,33 +560,91 @@
 	// 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.*`)
+	c.Check(ps.log.Captured(), Matches, `(?sm).* no persistable card:.*`)
+	c.Check(ps.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.counterBus, ss.hapticBus, ss.log)
+func (ps *postalSuite) TestMessageHandlerReportsFailedNotifies(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), 1)
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.NotificationsEndp = endp
+	c.Assert(svc.Start(), IsNil)
 	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}
-	err := svc.messageHandler("", "", output)
+	err := svc.messageHandler(&click.AppId{}, "", output)
 	c.Assert(err, NotNil)
 }
 
-func (ss *postalSuite) TestMessageHandlerReportsButIgnoresUnmarshalErrors(c *C) {
-	svc := NewPostalService(ss.bus, ss.notifBus, ss.counterBus, ss.hapticBus, ss.log)
+func (ps *postalSuite) TestMessageHandlerInhibition(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []windowstack.WindowsInfo{{0, "com.example.test_test-app", true, 0}})
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	svc.WindowStackEndp = endp
+	c.Assert(svc.Start(), IsNil)
+	output := &launch_helper.HelperOutput{} // Doesn't matter
+	err := svc.messageHandler(clickhelp.MustParseAppId("com.example.test_test-app_0"), "", output)
+	c.Check(err, IsNil)
+	c.Check(ps.log.Captured(), Matches, `(?sm).* Notification skipped because app is focused.*`)
+}
+
+func (ps *postalSuite) TestMessageHandlerReportsButIgnoresUnmarshalErrors(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	c.Assert(svc.Start(), IsNil)
 	output := &launch_helper.HelperOutput{[]byte(`broken`), nil}
-	err := svc.messageHandler("", "", output)
+	err := svc.messageHandler(nil, "", output)
 	c.Check(err, IsNil)
-	c.Check(ss.log.Captured(), Matches, "(?msi).*skipping notification: nil.*")
+	c.Check(ps.log.Captured(), Matches, "(?msi).*skipping notification: nil.*")
 }
 
-func (ss *postalSuite) TestMessageHandlerReportsButIgnoresNilNotifies(c *C) {
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
-	svc := NewPostalService(ss.bus, endp, ss.counterBus, ss.hapticBus, ss.log)
+func (ps *postalSuite) TestMessageHandlerReportsButIgnoresNilNotifies(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	c.Assert(svc.Start(), IsNil)
+	svc.NotificationsEndp = endp
 	output := &launch_helper.HelperOutput{[]byte(`{}`), nil}
-	err := svc.messageHandler("", "", output)
+	err := svc.messageHandler(nil, "", output)
 	c.Assert(err, IsNil)
-	c.Check(ss.log.Captured(), Matches, "(?msi).*skipping notification: nil.*")
+	c.Check(ps.log.Captured(), Matches, "(?msi).*skipping notification: nil.*")
+}
+
+func (ps *postalSuite) TestHandleActionsDispatches(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	c.Assert(svc.Start(), IsNil)
+	aCh := make(chan *notifications.RawAction)
+	rCh := make(chan *reply.MMActionReply)
+	bCh := make(chan bool)
+	go func() {
+		aCh <- nil // just in case?
+		aCh <- &notifications.RawAction{Action: "potato://"}
+		close(aCh)
+		bCh <- true
+	}()
+	go svc.handleActions(aCh, rCh)
+	takeNextBool(bCh)
+	args := testibus.GetCallArgs(ps.urlDispBus)
+	c.Assert(args, HasLen, 1)
+	c.Check(args[0].Member, Equals, "DispatchURL")
+	c.Assert(args[0].Args, HasLen, 1)
+	c.Assert(args[0].Args[0], Equals, "potato://")
+}
+
+func (ps *postalSuite) TestHandleMMUActionsDispatches(c *C) {
+	svc := ps.replaceBuses(NewPostalService(nil, ps.log))
+	c.Assert(svc.Start(), IsNil)
+	aCh := make(chan *notifications.RawAction)
+	rCh := make(chan *reply.MMActionReply)
+	bCh := make(chan bool)
+	go func() {
+		rCh <- nil // just in case?
+		rCh <- &reply.MMActionReply{Action: "potato://", Notification: "foo.bar"}
+		close(rCh)
+		bCh <- true
+	}()
+	go svc.handleActions(aCh, rCh)
+	takeNextBool(bCh)
+	args := testibus.GetCallArgs(ps.urlDispBus)
+	c.Assert(args, HasLen, 1)
+	c.Check(args[0].Member, Equals, "DispatchURL")
+	c.Assert(args[0].Args, HasLen, 1)
+	c.Assert(args[0].Args[0], Equals, "potato://")
 }

=== modified file 'client/service/service.go'
--- client/service/service.go	2014-07-04 19:23:40 +0000
+++ client/service/service.go	2014-07-21 14:14:04 +0000
@@ -26,17 +26,20 @@
 	"net/url"
 	"os"
 
+	http13 "launchpad.net/ubuntu-push/http13client"
+
 	"launchpad.net/ubuntu-push/bus"
-	http13 "launchpad.net/ubuntu-push/http13client"
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/logger"
 	"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
+	RegURL           *url.URL
+	DeviceId         string
+	AuthGetter       func(string) string
+	InstalledChecker click.InstalledChecker
 }
 
 // PushService is the dbus api
@@ -57,10 +60,11 @@
 )
 
 // NewPushService() builds a new service and returns it.
-func NewPushService(bus bus.Endpoint, setup *PushServiceSetup, log logger.Logger) *PushService {
+func NewPushService(setup *PushServiceSetup, log logger.Logger) *PushService {
 	var svc = &PushService{}
 	svc.Log = log
-	svc.Bus = bus
+	svc.Bus = bus.SessionBus.Endpoint(PushServiceBusAddress, log)
+	svc.installedChecker = setup.InstalledChecker
 	svc.regURL = setup.RegURL
 	svc.deviceId = setup.DeviceId
 	svc.authGetter = setup.AuthGetter
@@ -158,18 +162,18 @@
 }
 
 func (svc *PushService) register(path string, args, _ []interface{}) ([]interface{}, error) {
-	_, appId, err := grabDBusPackageAndAppId(path, args, 0)
+	app, err := svc.grabDBusPackageAndAppId(path, args, 0)
 	if err != nil {
 		return nil, err
 	}
 
-	rawAppId := string(nih.Quote([]byte(appId)))
+	rawAppId := string(nih.Quote([]byte(app.Original())))
 	rv := os.Getenv("PUSH_REG_" + rawAppId)
 	if rv != "" {
 		return []interface{}{rv}, nil
 	}
 
-	reply, err := svc.manageReg("/register", appId)
+	reply, err := svc.manageReg("/register", app.Original())
 	if err != nil {
 		return nil, err
 	}
@@ -183,12 +187,12 @@
 }
 
 func (svc *PushService) unregister(path string, args, _ []interface{}) ([]interface{}, error) {
-	_, appId, err := grabDBusPackageAndAppId(path, args, 0)
+	app, err := svc.grabDBusPackageAndAppId(path, args, 0)
 	if err != nil {
 		return nil, err
 	}
 
-	return nil, svc.Unregister(appId)
+	return nil, svc.Unregister(app.Original())
 }
 
 func (svc *PushService) Unregister(appId string) error {

=== modified file 'client/service/service_test.go'
--- client/service/service_test.go	2014-07-04 19:23:40 +0000
+++ client/service/service_test.go	2014-07-21 14:14:04 +0000
@@ -64,15 +64,15 @@
 			return ""
 		},
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
-	c.Check(svc.Bus, Equals, ss.bus)
+	svc := NewPushService(setup, ss.log)
 	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, testSetup, ss.log)
+	svc := NewPushService(testSetup, ss.log)
+	svc.Bus = ss.bus
 	c.Check(svc.IsRunning(), Equals, false)
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.IsRunning(), Equals, true)
@@ -80,31 +80,36 @@
 }
 
 func (ss *serviceSuite) TestStartTwice(c *C) {
-	svc := NewPushService(ss.bus, testSetup, ss.log)
+	svc := NewPushService(testSetup, ss.log)
+	svc.Bus = ss.bus
 	c.Check(svc.Start(), IsNil)
 	c.Check(svc.Start(), Equals, ErrAlreadyStarted)
 	svc.Stop()
 }
 
 func (ss *serviceSuite) TestStartNoLog(c *C) {
-	svc := NewPushService(ss.bus, testSetup, nil)
+	svc := NewPushService(testSetup, nil)
+	svc.Bus = ss.bus
 	c.Check(svc.Start(), Equals, ErrNotConfigured)
 }
 
 func (ss *serviceSuite) TestStartNoBus(c *C) {
-	svc := NewPushService(nil, testSetup, ss.log)
+	svc := NewPushService(testSetup, ss.log)
+	svc.Bus = nil
 	c.Check(svc.Start(), Equals, ErrNotConfigured)
 }
 
 func (ss *serviceSuite) TestStartFailsOnBusDialFailure(c *C) {
 	bus := testibus.NewTestingEndpoint(condition.Work(false), nil)
-	svc := NewPushService(bus, testSetup, ss.log)
+	svc := NewPushService(testSetup, ss.log)
+	svc.Bus = bus
 	c.Check(svc.Start(), ErrorMatches, `.*(?i)cond said no.*`)
 	svc.Stop()
 }
 
 func (ss *serviceSuite) TestStartGrabsName(c *C) {
-	svc := NewPushService(ss.bus, testSetup, ss.log)
+	svc := NewPushService(testSetup, ss.log)
+	svc.Bus = ss.bus
 	c.Assert(svc.Start(), IsNil)
 	callArgs := testibus.GetCallArgs(ss.bus)
 	defer svc.Stop()
@@ -113,7 +118,8 @@
 }
 
 func (ss *serviceSuite) TestStopClosesBus(c *C) {
-	svc := NewPushService(ss.bus, testSetup, ss.log)
+	svc := NewPushService(testSetup, ss.log)
+	svc.Bus = ss.bus
 	c.Assert(svc.Start(), IsNil)
 	svc.Stop()
 	callArgs := testibus.GetCallArgs(ss.bus)
@@ -132,7 +138,8 @@
 			return "Auth " + s
 		},
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
 	url, auth := svc.getAuthorization("/op")
 	c.Check(auth, Equals, "Auth http://foo/op")
 	c.Assert(len(ch), Equals, 1)
@@ -141,7 +148,8 @@
 }
 
 func (ss *serviceSuite) TestGetRegAuthDoesNotPanic(c *C) {
-	svc := NewPushService(ss.bus, testSetup, ss.log)
+	svc := NewPushService(testSetup, ss.log)
+	svc.Bus = ss.bus
 	_, auth := svc.getAuthorization("/op")
 	c.Check(auth, Equals, "")
 }
@@ -185,7 +193,8 @@
 		RegURL:     helpers.ParseURL(ts.URL),
 		AuthGetter: func(string) string { return "tok" },
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
 	// this'll check (un)quoting, too
 	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Assert(err, IsNil)
@@ -210,7 +219,8 @@
 
 func (ss *serviceSuite) TestManageRegFailsOnBadAuth(c *C) {
 	// ... no auth added
-	svc := NewPushService(ss.bus, testSetup, ss.log)
+	svc := NewPushService(testSetup, ss.log)
+	svc.Bus = ss.bus
 	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(reg, IsNil)
 	c.Check(err, Equals, ErrBadAuth)
@@ -222,7 +232,8 @@
 		RegURL:     helpers.ParseURL("xyzzy://"),
 		AuthGetter: func(string) string { return "tok" },
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
 	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(reg, IsNil)
 	c.Check(err, ErrorMatches, "unable to request registration: .*")
@@ -238,7 +249,8 @@
 		RegURL:     helpers.ParseURL(ts.URL),
 		AuthGetter: func(string) string { return "tok" },
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
 	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(err, Equals, ErrBadRequest)
 	c.Check(reg, IsNil)
@@ -254,7 +266,8 @@
 		RegURL:     helpers.ParseURL(ts.URL),
 		AuthGetter: func(string) string { return "tok" },
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
 	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(err, Equals, ErrBadServer)
 	c.Check(reg, IsNil)
@@ -278,7 +291,8 @@
 		RegURL:     helpers.ParseURL(ts.URL),
 		AuthGetter: func(string) string { return "tok" },
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
 	// this'll check (un)quoting, too
 	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(reg, IsNil)
@@ -303,7 +317,8 @@
 		RegURL:     helpers.ParseURL(ts.URL),
 		AuthGetter: func(string) string { return "tok" },
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
 	// this'll check (un)quoting, too
 	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Check(reg, IsNil)
@@ -328,7 +343,8 @@
 		RegURL:     helpers.ParseURL(ts.URL),
 		AuthGetter: func(string) string { return "tok" },
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
 	// this'll check (un)quoting, too
 	reg, err := svc.unregister(aPackageOnBus, []interface{}{anAppId}, nil)
 	c.Assert(err, IsNil)
@@ -355,7 +371,8 @@
 		RegURL:     helpers.ParseURL(ts.URL),
 		AuthGetter: func(string) string { return "tok" },
 	}
-	svc := NewPushService(ss.bus, setup, ss.log)
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
 	err := svc.Unregister(anAppId)
 	c.Assert(err, IsNil)
 	c.Check(invoked, HasLen, 1)

=== modified file 'client/session/session.go'
--- client/session/session.go	2014-07-03 19:50:38 +0000
+++ client/session/session.go	2014-07-21 14:14:04 +0000
@@ -31,6 +31,7 @@
 	"sync/atomic"
 	"time"
 
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/client/gethosts"
 	"launchpad.net/ubuntu-push/client/session/seenstate"
 	"launchpad.net/ubuntu-push/logger"
@@ -81,7 +82,14 @@
 // AddresseeChecking can check if a notification can be delivered.
 type AddresseeChecking interface {
 	StartAddresseeBatch()
-	CheckForAddressee(*protocol.Notification) bool
+	CheckForAddressee(*protocol.Notification) *click.AppId
+}
+
+// AddressedNotification carries both a protocol.Notification and a parsed
+// AppId addressee.
+type AddressedNotification struct {
+	To           *click.AppId
+	Notification *protocol.Notification
 }
 
 // ClientSessionConfig groups the client session configuration.
@@ -126,7 +134,7 @@
 	stateP          *uint32
 	ErrCh           chan error
 	BroadcastCh     chan *BroadcastNotification
-	NotificationsCh chan *protocol.Notification
+	NotificationsCh chan AddressedNotification
 	// authorization
 	auth string
 	// autoredial knobs
@@ -436,13 +444,14 @@
 	sess.AddresseeChecker.StartAddresseeBatch()
 	for i := range notifs {
 		notif := &notifs[i]
-		if !sess.AddresseeChecker.CheckForAddressee(notif) {
+		to := sess.AddresseeChecker.CheckForAddressee(notif)
+		if to == nil {
 			continue
 		}
 		sess.Log.Debugf("unicast app:%v msg:%s payload:%s",
 			notif.AppId, notif.MsgId, notif.Payload)
 		sess.Log.Debugf("sending ucast over")
-		sess.NotificationsCh <- notif
+		sess.NotificationsCh <- AddressedNotification{to, notif}
 		sess.Log.Debugf("sent ucast over")
 	}
 	return nil
@@ -572,7 +581,7 @@
 		if err == nil {
 			sess.ErrCh = make(chan error, 1)
 			sess.BroadcastCh = make(chan *BroadcastNotification)
-			sess.NotificationsCh = make(chan *protocol.Notification)
+			sess.NotificationsCh = make(chan AddressedNotification)
 			go func() { sess.ErrCh <- looper() }()
 		}
 	}

=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-07-03 19:50:38 +0000
+++ client/session/session_test.go	2014-07-21 14:14:04 +0000
@@ -32,6 +32,7 @@
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/client/gethosts"
 	"launchpad.net/ubuntu-push/client/session/seenstate"
 	"launchpad.net/ubuntu-push/protocol"
@@ -636,7 +637,7 @@
 	s.sess.proto = &testProtocol{up: s.upCh, down: s.downCh}
 	// make the message channel buffered
 	s.sess.BroadcastCh = make(chan *BroadcastNotification, 5)
-	s.sess.NotificationsCh = make(chan *protocol.Notification, 5)
+	s.sess.NotificationsCh = make(chan AddressedNotification, 5)
 }
 
 func (s *msgSuite) TestHandlePingWorks(c *C) {
@@ -807,9 +808,17 @@
 	ac.ops <- "start"
 }
 
-func (ac *testAddresseeChecking) CheckForAddressee(notif *protocol.Notification) bool {
+func (ac *testAddresseeChecking) CheckForAddressee(notif *protocol.Notification) *click.AppId {
 	ac.ops <- notif.AppId
-	return notif.AppId != ac.missing
+	if notif.AppId != ac.missing {
+		id, err := click.ParseAppId(notif.AppId)
+		if err != nil {
+			panic(err)
+		}
+		return id
+	} else {
+		return nil
+	}
 }
 
 func (s *msgSuite) TestHandleNotificationsWorks(c *C) {
@@ -817,12 +826,12 @@
 	s.sess.AddresseeChecker = ac
 	s.sess.setShouldDelay()
 	n1 := protocol.Notification{
-		AppId:   "app1",
+		AppId:   "com.example.app1_app1",
 		MsgId:   "a",
 		Payload: json.RawMessage(`{"m": 1}`),
 	}
 	n2 := protocol.Notification{
-		AppId:   "app2",
+		AppId:   "com.example.app2_app2",
 		MsgId:   "b",
 		Payload: json.RawMessage(`{"m": 2}`),
 	}
@@ -837,28 +846,38 @@
 	c.Check(<-s.errCh, Equals, nil)
 	c.Check(s.sess.ShouldDelay(), Equals, false)
 	c.Assert(s.sess.NotificationsCh, HasLen, 2)
-	c.Check(<-s.sess.NotificationsCh, DeepEquals, &n1)
-	c.Check(<-s.sess.NotificationsCh, DeepEquals, &n2)
+	app1, err := click.ParseAppId("com.example.app1_app1")
+	c.Assert(err, IsNil)
+	c.Check(<-s.sess.NotificationsCh, DeepEquals, AddressedNotification{
+		To:           app1,
+		Notification: &n1,
+	})
+	app2, err := click.ParseAppId("com.example.app2_app2")
+	c.Assert(err, IsNil)
+	c.Check(<-s.sess.NotificationsCh, DeepEquals, AddressedNotification{
+		To:           app2,
+		Notification: &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")
+	c.Check(<-ac.ops, Equals, "com.example.app1_app1")
+	c.Check(<-ac.ops, Equals, "com.example.app2_app2")
 }
 
 func (s *msgSuite) TestHandleNotificationsAddresseeCheck(c *C) {
 	ac := &testAddresseeChecking{
 		ops:     make(chan string, 10),
-		missing: "app1",
+		missing: "com.example.app1_app1",
 	}
 	s.sess.AddresseeChecker = ac
 	s.sess.setShouldDelay()
 	n1 := protocol.Notification{
-		AppId:   "app1",
+		AppId:   "com.example.app1_app1",
 		MsgId:   "a",
 		Payload: json.RawMessage(`{"m": 1}`),
 	}
 	n2 := protocol.Notification{
-		AppId:   "app2",
+		AppId:   "com.example.app2_app2",
 		MsgId:   "b",
 		Payload: json.RawMessage(`{"m": 2}`),
 	}
@@ -873,22 +892,27 @@
 	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)
+	app2, err := click.ParseAppId("com.example.app2_app2")
+	c.Assert(err, IsNil)
+	c.Check(<-s.sess.NotificationsCh, DeepEquals, AddressedNotification{
+		To:           app2,
+		Notification: &n2,
+	})
 	c.Check(ac.ops, HasLen, 3)
 	c.Check(<-ac.ops, Equals, "start")
-	c.Check(<-ac.ops, Equals, "app1")
+	c.Check(<-ac.ops, Equals, "com.example.app1_app1")
 }
 
 func (s *msgSuite) TestHandleNotificationsFiltersSeen(c *C) {
 	ac := &testAddresseeChecking{ops: make(chan string, 10)}
 	s.sess.AddresseeChecker = ac
 	n1 := protocol.Notification{
-		AppId:   "app1",
+		AppId:   "com.example.app1_app1",
 		MsgId:   "a",
 		Payload: json.RawMessage(`{"m": 1}`),
 	}
 	n2 := protocol.Notification{
-		AppId:   "app2",
+		AppId:   "com.example.app2_app2",
 		MsgId:   "b",
 		Payload: json.RawMessage(`{"m": 2}`),
 	}
@@ -902,8 +926,18 @@
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, Equals, nil)
 	c.Assert(s.sess.NotificationsCh, HasLen, 2)
-	c.Check(<-s.sess.NotificationsCh, DeepEquals, &n1)
-	c.Check(<-s.sess.NotificationsCh, DeepEquals, &n2)
+	app1, err := click.ParseAppId("com.example.app1_app1")
+	c.Assert(err, IsNil)
+	c.Check(<-s.sess.NotificationsCh, DeepEquals, AddressedNotification{
+		To:           app1,
+		Notification: &n1,
+	})
+	app2, err := click.ParseAppId("com.example.app2_app2")
+	c.Assert(err, IsNil)
+	c.Check(<-s.sess.NotificationsCh, DeepEquals, AddressedNotification{
+		To:           app2,
+		Notification: &n2,
+	})
 	c.Check(ac.ops, HasLen, 3)
 
 	// second time they get ignored
@@ -918,7 +952,7 @@
 func (s *msgSuite) TestHandleNotificationsBadAckWrite(c *C) {
 	s.sess.setShouldDelay()
 	n1 := protocol.Notification{
-		AppId:   "app1",
+		AppId:   "com.example.app1_app1",
 		MsgId:   "a",
 		Payload: json.RawMessage(`{"m": 1}`),
 	}
@@ -941,7 +975,7 @@
 	s.sess.setShouldDelay()
 	s.sess.SeenState = &brokenSeenState{}
 	n1 := protocol.Notification{
-		AppId:   "app1",
+		AppId:   "com.example.app1_app1",
 		MsgId:   "a",
 		Payload: json.RawMessage(`{"m": 1}`),
 	}

=== modified file 'debian/changelog'
--- debian/changelog	2014-07-07 14:26:27 +0000
+++ debian/changelog	2014-07-21 14:14:04 +0000
@@ -1,3 +1,55 @@
+ubuntu-push (0.49-0ubuntu1) UNRELEASED; urgency=medium
+
+  [Samuele Pedroni]
+  * Check in the api whether an app has pushed too many notifications.
+  * Return payload of most recent notification in too many pending
+    notifications API error.
+  * Introduce clear_pending flag to clean everything pending for an app.
+  * Refactor and cleanup.
+  * Introduce replace_tag support in store and api, with acceptance test.
+  * Teach a couple of trick to cmd/acceptanceclient: exit on run timeout,
+    wait for event matching given regexp pattern.
+  * Limit unicast data payload to 2K.
+  * Payload should be json (fixes message needing to be base64-encoded in
+    helper reply)
+  * Implement limited mboxes
+  * Refactor and cleanup of things done in haste by Chipaca.
+
+  [Richard Huddie]
+  * autopilot test framework and basic coverage of broadcast notifications.
+
+  [Guillermo Gonzalez]
+  * Add scripts to simplify setup/run of the autopilot tests in the
+    device/emulator and include basic unicast tests.
+  * Add autopilot test for notification using the emblem counter.
+  * Adds scenarios to the autopilot tests for legacy and click (without
+    version) applications.
+  * Broadcast via the helpers route.
+  * Basic support for actions (only default action) in the persistent
+    notifications.
+  * Change PostBroadcast to send the broadcast message to the software
+    updates helper.
+
+  [John R. Lenton]
+  * Detangle client and postal.
+  * Introduce PostalService interface, and change the client tests to use
+    that as much as reasonable.
+  * Async invocation of helpers.
+  * Give click.Click knowledge of helpers.
+  * Write ual-based helper launcher.
+  * Switch to the ual-based helper launcher unless the environment
+    variable UBUNTU_PUSH_USE_TRIVIAL_HELPER is set.
+  * Threw together an implementation of helpers for legacy applications.
+  * Hacked up an initial software updates helper, to be handed off to the
+    appropriate team shortly.
+
+  [Roberto Alsina]
+  * Wrap the (dbus) WindowStack API and add endpoint to the Postal service
+    to support inhibition of notifications for focused apps.
+  * Inhibit notifications for focused apps
+
+ -- John R. Lenton <[e-mail]>  Thu, 17 Jul 2014 13:26:48 +0100
+
 ubuntu-push (0.43+14.10.20140707-0ubuntu1) utopic; urgency=medium
 
   [ Samuele Pedroni ]

=== modified file 'debian/control'
--- debian/control	2014-07-04 09:17:49 +0000
+++ debian/control	2014-07-21 14:14:04 +0000
@@ -22,6 +22,7 @@
                libnih-dbus-dev,
                libclick-0.4-dev,
                cmake,
+               python3.4,
 Standards-Version: 3.9.5
 Homepage: http://launchpad.net/ubuntu-push
 Vcs-Bzr: lp:ubuntu-push
@@ -49,3 +50,23 @@
  The Ubuntu Push Notifications client-side daemon library.
  .
  This package contains the source.
+
+Package: ubuntu-push-dev-server
+Architecture: any
+Multi-Arch: foreign
+Depends: ${misc:Depends},
+         ${shlibs:Depends},
+Built-Using: ${misc:Built-Using}
+Description: Ubuntu Push Notifications development & testing server
+ The Ubuntu Push Notifications dev & testing server.
+
+Package: ubuntu-push-autopilot
+Architecture: any
+Multi-Arch: foreign
+Depends: unity8-autopilot,
+         unity-scope-click,
+         ubuntu-push-client,
+Recommends: ubuntu-push-dev-server,
+Built-Using: ${misc:Built-Using}
+Description: Ubuntu Push Notifications autopilot tests
+ The Ubuntu Push Notifications autopilot tests.

=== added file 'debian/exec-tool'
--- debian/exec-tool	1970-01-01 00:00:00 +0000
+++ debian/exec-tool	2014-07-21 14:14:04 +0000
@@ -0,0 +1,2 @@
+#!/bin/sh
+initctl set-env "APP_EXEC=$APP_URIS"

=== added file 'debian/push-helper.hook'
--- debian/push-helper.hook	1970-01-01 00:00:00 +0000
+++ debian/push-helper.hook	2014-07-21 14:14:04 +0000
@@ -0,0 +1,3 @@
+Pattern: ${home}/.local/share/push-helpers/${short-id}.json
+User-Level: yes
+Hook-Name: push-helper

=== modified file 'debian/rules'
--- debian/rules	2014-06-23 12:46:28 +0000
+++ debian/rules	2014-07-21 14:14:04 +0000
@@ -12,10 +12,10 @@
 # (should go away once we ship go 1.3)
 override_dh_auto_test:
 	cd $$( find ./ -type d -regex '\./[^/]*/src/launchpad.net' -printf "%h\n" | head -n1) && \
-	env GOPATH=$$(cd ..; pwd) go test $$(env GOPATH=$$(cd ..; pwd) go list $(DH_GOPKG)/... | grep -v acceptance | grep -v http13client )
+	env GOPATH=$$(cd ..; pwd) go test -v $$(env GOPATH=$$(cd ..; pwd) go list $(DH_GOPKG)/... | grep -v acceptance | grep -v http13client )
 
 override_dh_install:
-	dh_install -Xusr/bin/cmd -Xusr/bin/dev --fail-missing
+	dh_install -Xusr/bin/cmd --fail-missing
 
 %:
 	dh $@ --buildsystem=golang --with=golang

=== added file 'debian/ubuntu-push-autopilot.install'
--- debian/ubuntu-push-autopilot.install	1970-01-01 00:00:00 +0000
+++ debian/ubuntu-push-autopilot.install	2014-07-21 14:14:04 +0000
@@ -0,0 +1,1 @@
+tests/autopilot/push_notifications/ /usr/lib/python3/dist-packages

=== modified file 'debian/ubuntu-push-client.install'
--- debian/ubuntu-push-client.install	2014-04-30 18:10:31 +0000
+++ debian/ubuntu-push-client.install	2014-07-21 14:14:04 +0000
@@ -1,5 +1,8 @@
 #!/usr/bin/dh-exec
 debian/config.json /etc/xdg/ubuntu-push-client
 debian/ubuntu-push-client.conf /usr/share/upstart/sessions
+debian/exec-tool /usr/lib/${DEB_HOST_MULTIARCH}/ubuntu-app-launch/push-helper
+debian/push-helper.hook /usr/share/click/hooks
 signing-helper/signing-helper /usr/lib/ubuntu-push-client
 usr/bin/ubuntu-push => /usr/lib/ubuntu-push-client/ubuntu-push-client
+scripts/software-updates-helper.py => /usr/lib/ubuntu-push-client/legacy-helpers/ubuntu-system-settings

=== added file 'debian/ubuntu-push-dev-server.install'
--- debian/ubuntu-push-dev-server.install	1970-01-01 00:00:00 +0000
+++ debian/ubuntu-push-dev-server.install	2014-07-21 14:14:04 +0000
@@ -0,0 +1,2 @@
+#!/usr/bin/dh-exec
+usr/bin/dev => /usr/bin/ubuntu-push-dev-server

=== added directory 'launch_helper/cual'
=== added file 'launch_helper/cual/cual.go'
--- launch_helper/cual/cual.go	1970-01-01 00:00:00 +0000
+++ launch_helper/cual/cual.go	2014-07-21 14:14:04 +0000
@@ -0,0 +1,97 @@
+/*
+ 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 cual
+
+/*
+#cgo pkg-config: ubuntu-app-launch-2
+#include <glib.h>
+
+gboolean add_observer (gpointer);
+gboolean remove_observer (gpointer);
+char* launch(gchar* app_id, gchar* exec, gchar* f1, gchar* f2, gpointer p);
+gboolean stop(gchar* app_id, gchar* iid);
+*/
+import "C"
+import (
+	"errors"
+	"unsafe"
+
+	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+func gstring(s string) *C.gchar {
+	return (*C.gchar)(C.CString(s))
+}
+
+type helperState struct {
+	log  logger.Logger
+	done func(string)
+}
+
+//export helperDone
+func helperDone(gp unsafe.Pointer, ciid *C.char) {
+	hs := (*helperState)(gp)
+	iid := C.GoString(ciid)
+	hs.done(iid)
+}
+
+var (
+	ErrCantObserve   = errors.New("can't add observer")
+	ErrCantUnobserve = errors.New("can't remove observer")
+	ErrCantLaunch    = errors.New("can't launch helper")
+	ErrCantStop      = errors.New("can't stop helper")
+)
+
+func New(log logger.Logger) *helperState {
+	return &helperState{log: log}
+}
+
+func (hs *helperState) InstallObserver(done func(string)) error {
+	hs.done = done
+	if C.add_observer(C.gpointer(hs)) != C.TRUE {
+		return ErrCantObserve
+	}
+	return nil
+}
+
+func (hs *helperState) RemoveObserver() error {
+	if C.remove_observer(C.gpointer(hs)) != C.TRUE {
+		return ErrCantUnobserve
+	}
+	return nil
+}
+
+func (hs *helperState) HelperInfo(app *click.AppId) (string, string) {
+	return app.Helper()
+}
+
+func (hs *helperState) Launch(appId, exec, f1, f2 string) (string, error) {
+	// launch(...) takes over ownership of things passed in
+	iid := C.GoString(C.launch(gstring(appId), gstring(exec), gstring(f1), gstring(f2), C.gpointer(hs)))
+	if iid == "" {
+		return "", ErrCantLaunch
+	}
+	return iid, nil
+}
+
+func (hs *helperState) Stop(appId, instanceId string) error {
+	if C.stop(gstring(appId), gstring(instanceId)) != C.TRUE {
+		return ErrCantStop
+	}
+	return nil
+}

=== added file 'launch_helper/cual/cual_c.go'
--- launch_helper/cual/cual_c.go	1970-01-01 00:00:00 +0000
+++ launch_helper/cual/cual_c.go	2014-07-21 14:14:04 +0000
@@ -0,0 +1,57 @@
+/*
+ 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 cual
+
+// this is a .go to work around limitations in dh-golang
+
+/*
+#include <ubuntu-app-launch.h>
+#include <glib.h>
+
+#define HELPER_ERROR g_quark_from_static_string ("cgo-ual-helper-error-quark")
+
+static void observer_of_stop (const gchar * app_id, const gchar * instance_id, const gchar * helper_type, gpointer user_data) {
+    helperDone (user_data, instance_id);
+}
+
+char* launch(gchar* app_id, gchar* exec, gchar* f1, gchar* f2, gpointer p) {
+    const gchar* uris[4] = {exec, f1, f2, NULL};
+    gchar* iid = ubuntu_app_launch_start_multiple_helper ("push-helper", app_id, uris);
+    g_free (app_id);
+    g_free (exec);
+    g_free (f1);
+    g_free (f2);
+    return iid;
+}
+
+gboolean add_observer(gpointer p) {
+    return ubuntu_app_launch_observer_add_helper_stop(observer_of_stop, "push-helper", p);
+}
+
+gboolean remove_observer(gpointer p) {
+    return ubuntu_app_launch_observer_delete_helper_stop(observer_of_stop, "push-helper", p);
+}
+
+gboolean stop(gchar* app_id, gchar* iid) {
+    gboolean res;
+    res = ubuntu_app_launch_stop_multiple_helper ("push-helper", app_id, iid);
+    g_free (app_id);
+    g_free (iid);
+    return res;
+}
+*/
+import "C"

=== modified file 'launch_helper/helper.go'
--- launch_helper/helper.go	2014-06-30 17:00:54 +0000
+++ launch_helper/helper.go	2014-07-21 14:14:04 +0000
@@ -24,28 +24,41 @@
 	"launchpad.net/ubuntu-push/logger"
 )
 
-type HelperLauncher interface {
-	Run(appId string, message []byte) *HelperOutput
-}
-
 type trivialHelperLauncher struct {
-	log logger.Logger
-}
-
-// a trivial HelperLauncher that doesn't launch anything at all
-func NewTrivialHelperLauncher(log logger.Logger) HelperLauncher {
-	return &trivialHelperLauncher{log}
-}
-
-func (triv *trivialHelperLauncher) Run(appId string, message []byte) *HelperOutput {
-	out := new(HelperOutput)
-	err := json.Unmarshal(message, out)
-	if err == nil {
-		return out
-	}
-	triv.log.Debugf("failed to parse HelperOutput from message, leaving it alone: %v", err)
-	out.Message = message
-	out.Notification = nil
-
-	return out
+	log   logger.Logger
+	chOut chan *HelperResult
+	chIn  chan *HelperInput
+}
+
+// a trivial HelperPool that doesn't launch anything at all
+func NewTrivialHelperPool(log logger.Logger) HelperPool {
+	return &trivialHelperLauncher{log: log}
+}
+
+func (triv *trivialHelperLauncher) Start() chan *HelperResult {
+	triv.chOut = make(chan *HelperResult)
+	triv.chIn = make(chan *HelperInput, InputBufferSize)
+
+	go func() {
+		for i := range triv.chIn {
+			res := &HelperResult{Input: i}
+			err := json.Unmarshal(i.Payload, &res.HelperOutput)
+			if err != nil {
+				triv.log.Debugf("failed to parse HelperOutput from message, leaving it alone: %v", err)
+				res.Message = i.Payload
+				res.Notification = nil
+			}
+			triv.chOut <- res
+		}
+	}()
+
+	return triv.chOut
+}
+
+func (triv *trivialHelperLauncher) Stop() {
+	close(triv.chIn)
+}
+
+func (triv *trivialHelperLauncher) Run(kind string, input *HelperInput) {
+	triv.chIn <- input
 }

=== modified file 'launch_helper/helper_output.go'
--- launch_helper/helper_output.go	2014-07-06 13:53:42 +0000
+++ launch_helper/helper_output.go	2014-07-21 14:14:04 +0000
@@ -16,6 +16,12 @@
 
 package launch_helper
 
+import (
+	"encoding/json"
+
+	"launchpad.net/ubuntu-push/click"
+)
+
 // a Card is the usual “visual” presentation of a notification, used
 // for bubbles and the notification centre (neé messaging menu)
 type Card struct {
@@ -52,6 +58,20 @@
 
 // HelperOutput is the expected output of a helper
 type HelperOutput struct {
-	Message      []byte        `json:"message"`      // what to put in the post office's queue
-	Notification *Notification `json:"notification"` // what to present to the user
+	Message      json.RawMessage `json:"message,omitempty"`      // what to put in the post office's queue
+	Notification *Notification   `json:"notification,omitempty"` // what to present to the user
+}
+
+// HelperResult is the result of a helper run for a particular app id
+type HelperResult struct {
+	HelperOutput
+	Input *HelperInput
+}
+
+// HelperInput is what's passed in to a helper for it to work
+type HelperInput struct {
+	kind           string
+	App            *click.AppId
+	NotificationId string
+	Payload        json.RawMessage
 }

=== modified file 'launch_helper/helper_test.go'
--- launch_helper/helper_test.go	2014-06-30 17:00:54 +0000
+++ launch_helper/helper_test.go	2014-07-21 14:14:04 +0000
@@ -17,10 +17,14 @@
 package launch_helper
 
 import (
+	"encoding/json"
 	"testing"
+	"time"
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/click"
+	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	helpers "launchpad.net/ubuntu-push/testing"
 )
 
@@ -28,30 +32,60 @@
 
 type runnerSuite struct {
 	testlog *helpers.TestLogger
+	app     *click.AppId
 }
 
 var _ = Suite(&runnerSuite{})
 
 func (s *runnerSuite) SetUpTest(c *C) {
 	s.testlog = helpers.NewTestLogger(c, "error")
+	s.app = clickhelp.MustParseAppId("com.example.test_test-app_0")
 }
 
-func (s *runnerSuite) TestTrivialRunnerWorks(c *C) {
+func (s *runnerSuite) TestTrivialPoolWorks(c *C) {
 	notif := &Notification{Sound: "42"}
 
-	triv := NewTrivialHelperLauncher(s.testlog)
-	// []byte is sent as a base64-encoded string
-	out := triv.Run("foo", []byte(`{"message": "aGVsbG8=", "notification": {"sound": "42"}}`))
+	triv := NewTrivialHelperPool(s.testlog)
+	ch := triv.Start()
+	in := &HelperInput{App: s.app, Payload: []byte(`{"message": {"m":42}, "notification": {"sound": "42"}}`)}
+	triv.Run("klick", in)
+	out := <-ch
 	c.Assert(out, NotNil)
-	c.Check(out.Message, DeepEquals, []byte("hello"))
+	c.Check(out.Message, DeepEquals, json.RawMessage(`{"m":42}`))
 	c.Check(out.Notification, DeepEquals, notif)
-}
-
-func (s *runnerSuite) TestTrivialRunnerWorksOnBadInput(c *C) {
-	triv := NewTrivialHelperLauncher(s.testlog)
+	c.Check(out.Input, DeepEquals, in)
+}
+
+func (s *runnerSuite) TestTrivialPoolWorksOnBadInput(c *C) {
+	triv := NewTrivialHelperPool(s.testlog)
+	ch := triv.Start()
+	msg := []byte(`{card: 3}`)
+	in := &HelperInput{App: s.app, Payload: msg}
+	triv.Run("klick", in)
+	out := <-ch
+	c.Assert(out, NotNil)
+	c.Check(out.Notification, IsNil)
+	c.Check(out.Message, DeepEquals, json.RawMessage(msg))
+	c.Check(out.Input, DeepEquals, in)
+}
+
+func (s *runnerSuite) TestTrivialPoolDoesNotBlockEasily(c *C) {
+	triv := NewTrivialHelperPool(s.testlog)
+	triv.Start()
 	msg := []byte(`this is a not your grandmother's json message`)
-	out := triv.Run("foo", msg)
-	c.Assert(out, NotNil)
-	c.Check(out.Notification, IsNil)
-	c.Check(out.Message, DeepEquals, msg)
+	in := &HelperInput{App: s.app, Payload: msg}
+	flagCh := make(chan bool)
+	go func() {
+		// stuff several in there
+		triv.Run("klick", in)
+		triv.Run("klick", in)
+		triv.Run("klick", in)