Mir

include/server/mir/default_server_configuration.h (+3/-0)
include/server/mir/input/android/default_android_input_configuration.h (+3/-0)
include/server/mir/input/touch_visualizer.h (+58/-0)
include/test/mir_test/event_factory.h (+12/-1)
include/test/mir_test/fake_event_hub_input_configuration.h (+2/-0)
include/test/mir_test_doubles/stub_touch_visualizer.h (+43/-0)
include/test/mir_test_framework/input_testing_server_configuration.h (+1/-1)
server-ABI-sha1sums (+3/-2)
src/server/input/android/android_input_reader_policy.cpp (+7/-2)
src/server/input/android/android_input_reader_policy.h (+4/-1)
src/server/input/android/android_pointer_controller.cpp (+27/-13)
src/server/input/android/android_pointer_controller.h (+15/-9)
src/server/input/android/default_android_input_configuration.cpp (+3/-1)
src/server/input/default_configuration.cpp (+18/-0)
tests/acceptance-tests/CMakeLists.txt (+1/-0)
tests/acceptance-tests/test_client_input.cpp (+2/-2)
tests/acceptance-tests/test_server_shutdown.cpp (+2/-1)
tests/acceptance-tests/test_touchspot_visualization.cpp (+222/-0)
tests/integration-tests/input/android/test_android_cursor_listener.cpp (+3/-0)
tests/integration-tests/input/android/test_android_input_manager.cpp (+5/-1)
tests/mir_test_doubles/event_factory.cpp (+13/-5)
tests/mir_test_doubles/fake_event_hub.cpp (+8/-5)
tests/mir_test_doubles/fake_event_hub_input_configuration.cpp (+2/-1)
tests/mir_test_framework/input_testing_server_options.cpp (+2/-1)
tests/unit-tests/input/android/test_android_input_reader_policy.cpp (+3/-1)
tests/unit-tests/input/android/test_android_pointer_controller.cpp (+3/-1)

To merge this branch:

bzr merge lp:~mir-team/mir/touchspot-visualizer

Wishlist

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration	2014-07-30	Approve on 2014-08-06
Cemil Azizoglu (community)		2014-07-30	Approve on 2014-08-05
Alan Griffiths			Approve on 2014-08-04
Kevin DuBois		2014-07-30	Pending
Daniel van Vugt		2014-07-30	Pending
Review via email: mp+228903@code.launchpad.net

This proposal supersedes a proposal from 2014-06-26.

Commit message

Expose an interface for touch visualization.

Description of the change

Expose an interface for touch visualization. There is no in-tree implementation yet as that is blocked on the yet to come cursor-is-a-renderable support for non-client-surface-renderables-thingies.

This goes ahead and exposes the TouchVisualizer interface though, as Unity with QtCompositor will need a custom implementation anyway, so this unblocks downstreams.

Requested by QA.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-06-27: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:1726
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/2013/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/721
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/727/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/721
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/534
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/534/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/532
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/532/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/2161
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/2161/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1886
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/8908

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2013/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-06-30: Posted in a previous version of this proposal

The change in InputTestingServerConfiguration to call inject_input in on_start rather than exec is to solve an intermittent failure.

Namely, in extremely fast running tests (i.e. clientless tests), the tests could complete in the input threads, before on_start ever finishes, causing crashes in the TestingServerStatusListener. So we wait to inject input until the server is really started.

Revision history for this message

Kevin DuBois (kdub) wrote on 2014-06-30: Posted in a previous version of this proposal

Aren't touchspots just multiple cursors? (and, consquently, if cursors are a renderable, aren't touchspots just renderables too?) This interface seems to be making a distinctions. I'm okay with this approach, given that we don't require compositors to always implement a touch-spot visualization.

Will the DefaultDisplayBufferCompositor or the Scene/SurfaceStack own the TouchVisualizer object?

Oh, and also are we intending USC or unity8 to paint the touch-spots?

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-01: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2039/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-01: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2042/rebuild

review: Approve (continuous-integration)

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-07-01: Posted in a previous version of this proposal

> Aren't touchspots just multiple cursors? (and, consquently, if cursors are a
> renderable, aren't touchspots just renderables too?) This interface seems to
> be making a distinctions. I'm okay with this approach, given that we don't
> require compositors to always implement a touch-spot visualization.

I think we've been down this road with surfaces - which can supply renderables but are not renderables. I suspect the same is true of cursors and touchspots.

> Oh, and also are we intending USC or unity8 to paint the touch-spots?

I can imagine that apps (or nested mir servers) would want the facility to take over drawing from the session mir (or system mir).

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2014-07-07: Posted in a previous version of this proposal

Yep, touch spot visualization is a nice feature to have eventually...

(1) It looks like we should be exposing MirMotionEvent instead of defining new structures to translate to. Spot, Action etc are redundant with MirMotionEvent which is already publicly defined. I don't think we need to define new types as it only creates the need for more translation logic.

Given a copy of the latest MirMotionEvent struct, a compositor would easily have all the information it needs to visualize the touch points. Literally just send the latest MirMotionEvent to the compositor and you're done. So I don't think the complexity of the new interfaces here is justified.

review: Disapprove

Revision history for this message

Kevin DuBois (kdub) wrote on 2014-07-07: Posted in a previous version of this proposal

> Given a copy of the latest MirMotionEvent struct, a compositor would easily
> have all the information it needs to visualize the touch points. Literally
> just send the latest MirMotionEvent to the compositor and you're done. So I
> don't think the complexity of the new interfaces here is justified.

I agree on the complexity of the new interfaces point.
I think that we already have the interfaces hooked up all the way to the compositor via the Renderables/SceneElement system so that the compositor doesn't have to have a different concepts for the touchpoints/cursors/input events.

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-07-08: Posted in a previous version of this proposal

Alan/Kevin: My plan is to have a sort of controller object insert touchspot renderables in the scene. This is just the interface that object implements towards the input stack.

Daniel: Of course this could be implemented at the level of say InputFilter, and pass the motion events on to the compositor. This requires every compositor implementor to implement some stateful tracking of the touchspots, which is a slight burden compared to the ease of an instaneous visualize-these-touches-at-this-point style API. In addition its not that we are translating these structures to Mir event...rather the raw touch tracking in InputReader is synthesized to create MirEvent...so if we are already doing this stateful tracking why not just expose it this way?

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2014-07-08: Posted in a previous version of this proposal

I don't think the compositor would have to do any stateful tracking. MirMotionEvent already maintains the state as persistent pointer_coordinate indices (e.g. fingerpaint relies on this fact to choose colours). And regardless I don't see any of that as a requirement to instantaneously rendering little circles... unless you also wanted to add animations for gesture outcomes (like tap). I suspect that's excessive. All we want is instantaneous touch locations (empty/filled circles), which requires no state tracking.

OK, the structure conversion already exists, I know. So I guess in the absence of any expensive conversion then next priority should be to not increase complexity with too many new types. What if we typedef a struct for the existing MirMotionEvent.pointer_coordinates and pass that:

void TouchVisualizer::visualize_touches(MirMotionPointerCoordinates const& p) const;

Also, I feel that that interface is backwards. Perhaps we don't want a rendering interface to give to the input system. What if we reversed it and simply gave the compositor a "Touchscreen" interface from which it could get the list of touches? That somehow feels cleaner.

review: Needs Fixing

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2014-07-08: Posted in a previous version of this proposal

Hmm, I forgot you will need to force a redraw on every touch (even when no surfaces need redrawing). That's an interesting point to consider as we now have three future features all with the a similar requirement:
   1. Software cursors
   2. Desktop zoom
   3. Touchspot visualization

All of these features have a requirement to force a redraw based on input events only (even when no surfaces have changed). So it would be nice to establish a common interface for triggering recomposition. One less bespoke than was proposed in lp:~vanvugt/mir/zoom ...

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-08: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2088/rebuild

review: Approve (continuous-integration)

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-07-08: Posted in a previous version of this proposal

>> Also, I feel that that interface is backwards. Perhaps we don't want a rendering interface to >> give to the input system. What if we reversed it and simply gave the compositor a
>> "Touchscreen" interface from which it could get the list of touches? That somehow feels cleaner.

I don't plan to implement this in the compositor. Rather a controller object will insert touchspot renderables in to the scene.

You seem to be proposing 'ask don't tell' ;)

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2014-07-09: Posted in a previous version of this proposal

I think it's potentially bad idea for minor stuff like touch spots to ever be part of the scene. You're committing yourself to the overhead of maintaining structures/objects for trivial textures. That's certainly sub-optimal in complexity and performance. I'd rather we didn't commit all future shells to performance limitations imposed by the Qt scene graph approach.

Revision history for this message

Kevin DuBois (kdub) wrote on 2014-07-09: Posted in a previous version of this proposal

> Alan/Kevin: My plan is to have a sort of controller object insert touchspot
> renderables in the scene. This is just the interface that object implements
> towards the input stack.

ah, I mis-saw on the first pass. Well, my concerns are addressed, so +1 from me.

review: Approve

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-07-09: Posted in a previous version of this proposal

>> "Touchscreen" interface from which it could get the list of touches? That somehow feels
>> cleaner.
>> I'd rather we didn't commit all future shells to performance limitations imposed by the Qt
>> scene graph approach.

In this approach, the TouchspotVisualizer could be implemented by a controller object which manipulates the scene, or by a part of the compositor/renderer which implements direct mode rendering.

If we had this "Touchscreen" interface to query the list we would be set for direct mode but would need an additional notification interface and state tracker (reproducing information we already have) for retained mode.

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-07-09: Posted in a previous version of this proposal

>> I think it's potentially bad idea for minor stuff like touch spots to ever be part of the
>> scene.
>> You're committing yourself to the overhead of maintaining structures/objects for trivial
>> textures. That's certainly sub-optimal in complexity and performance.

So part of the in cursor and touchspot visualizations being a render-able is a performance based goal. A renderable representation makes it easy to allow hardware backends to render the input visualizations as overlays when appropriate (HWC, drm cursor API, or future DRM unified planes API), while still supporting a software fallback when required.

If we didn't have a retained representation of the input visualizations it seems like this could be really difficult.

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2014-07-11: Posted in a previous version of this proposal

Forgive me for not understanding anything that ends in "...Controller". That still doesn't fit my mental model of anything after all these years. :(

"If we had this "Touchscreen" interface to query the list we would be set for direct mode but would need an additional notification interface" ...
Yeah I realized that in my last comment on 2014-07-08. I guess it's not terrible for those three features to trigger redraws via different interfaces. But maybe not ideal either.

I might propose some changes that would aid in reducing the redundant structs concern I raised on 2014-07-07. I'll say "Needs fixing" based on that still. Also...

(2) The name "TouchVisualizer" feels sub-optimal even as a notification interface. The first reason is that it sounds like something independent of the compositor, but couldn't be if it's visualizing. On the other hand, if you generalized the name to not involve rendering at all (like "TouchObserver") then that's solved.

review: Needs Fixing

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2014-07-15: Posted in a previous version of this proposal

Update: On development-branch, pointer_coordinates is now defined as an array of MirMotionPointer. That new typedef might help avoid redundant new types here.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-16: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2171/rebuild

review: Approve (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-21: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2201/rebuild

review: Approve (continuous-integration)

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-07-21: Posted in a previous version of this proposal

>> I might propose some changes that would aid in reducing the redundant structs concern I raised on
>> 2014-07-07. I'll say "Needs fixing" based on that still. Also...

To me its more important to reduce the coupling between data structures than the number of types. There is a distinct concept here: one is a client input event (which is quite a few things...), the other is an instantaneous list of active touches in the global screen coordinate space.

Anyone else have thoughts?

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-07-21: Posted in a previous version of this proposal

>> The name "TouchVisualizer" feels sub-optimal even as a notification interface. The first reason is >> that it sounds like something independent of the compositor, but couldn't be if it's visualizing.

It's independent of the compositor in Qt Scenegraph and the cursor-is-a-renderable scenario.

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2014-07-22: Posted in a previous version of this proposal

I still disagree with adding redundant types. That's unnecessary complexity; bad for maintenance. But it's probably not a blocking objection.

Looks like this needs another proper review from someone still.

review: Abstain

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2014-07-22: Posted in a previous version of this proposal

Reviewed mostly for learning.

LGTM (but don't count this as a proper review)

review: Approve

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-30: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:1736
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/2263/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/1131
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/1137/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/1122/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/785/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/786/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-utopic-armhf/57/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2263/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-30: Posted in a previous version of this proposal

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2273/rebuild

review: Approve (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-30:

FAILED: Continuous integration, rev:1740
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~mir-team/mir/touchspot-visualizer/+merge/228903/+edit-commit-message

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2274/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-31:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2279/rebuild

review: Approve (continuous-integration)

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-07-31:

P.S. Only a resubmit because of adding dependency on sha1sum-script

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-08-01:

983 +#!/bin/sh
984 +find include/client include/shared/mir_toolkit | egrep "\.h$" | xargs sha1sum

Looks like you've confused bzr (not hard) as this looks like the prerequisite.

review: Needs Fixing

Revision history for this message

Robert Carr (robertcarr) wrote on 2014-08-04:

Hopefully bzr is less confused.

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2014-08-04:

> Hopefully bzr is less confused.

Yes.

review: Approve

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-08-04:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2306/rebuild

review: Approve (continuous-integration)

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2014-08-05:

LGTM

review: Approve

Revision history for this message

PS Jenkins bot (ps-jenkins) on 2014-08-06:

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'include/server/mir/default_server_configuration.h'
 --- include/server/mir/default_server_configuration.h	2014-07-22 11:22:48 +0000
 +++ include/server/mir/default_server_configuration.h	2014-08-04 16:03:26 +0000
@@ -120,6 +120,7 @@
  class InputChannelFactory;
  class InputConfiguration;
  class CursorListener;
++class TouchVisualizer;
  class InputRegion;
  class InputSender;
  class InputSendObserver;
@@ -285,6 +286,7 @@
      virtual std::shared_ptr<shell::InputTargeter> the_input_targeter();
      virtual std::shared_ptr<input::InputTargets>  the_input_targets();
      virtual std::shared_ptr<input::CursorListener> the_cursor_listener();
++    virtual std::shared_ptr<input::TouchVisualizer> the_touch_visualizer();
      virtual std::shared_ptr<input::InputRegion>    the_input_region();
      /** @} */
@@ -343,6 +345,7 @@
      CachedPtr<input::InputRegion>     input_region;
      CachedPtr<shell::InputTargeter> input_targeter;
      CachedPtr<input::CursorListener> cursor_listener;
++    CachedPtr<input::TouchVisualizer> touch_visualizer;
      CachedPtr<graphics::Platform>     graphics_platform;
      CachedPtr<graphics::NativePlatform>    graphics_native_platform;
      CachedPtr<graphics::BufferInitializer> buffer_initializer;
 === modified file 'include/server/mir/input/android/default_android_input_configuration.h'
 --- include/server/mir/input/android/default_android_input_configuration.h	2014-06-24 15:28:09 +0000
 +++ include/server/mir/input/android/default_android_input_configuration.h	2014-08-04 16:03:26 +0000
@@ -40,6 +40,7 @@
+ {
  class InputRegion;
  class CursorListener;
++class TouchVisualizer;
  class InputReport;
  class InputDispatcher;
@@ -53,6 +54,7 @@
      DefaultInputConfiguration(std::shared_ptr<input::InputDispatcher> const& dispatcher,
                                std::shared_ptr<input::InputRegion> const& input_region,
                                std::shared_ptr<CursorListener> const& cursor_listener,
++                              std::shared_ptr<TouchVisualizer> const& touch_visualizer,
                                std::shared_ptr<input::InputReport> const& input_report);
      virtual ~DefaultInputConfiguration();
@@ -78,6 +80,7 @@
      std::shared_ptr<input::InputDispatcher> const input_dispatcher;
      std::shared_ptr<input::InputRegion> const input_region;
      std::shared_ptr<CursorListener> const cursor_listener;
++    std::shared_ptr<TouchVisualizer> const touch_visualizer;
      std::shared_ptr<input::InputReport> const input_report;
  };
+ }
 === added file 'include/server/mir/input/touch_visualizer.h'
 --- include/server/mir/input/touch_visualizer.h	1970-01-01 00:00:00 +0000
 +++ include/server/mir/input/touch_visualizer.h	2014-08-04 16:03:26 +0000
@@ -0,0 +1,58 @@
++/*
++ * 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 warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Robert Carr <robert.carr@canonical.com>
++ */
++
++#ifndef MIR_INPUT_TOUCH_VISUALIZER_H_
++#define MIR_INPUT_TOUCH_VISUALIZER_H_
++
++#include "mir/geometry/point.h"
++
++#include <vector>
++
++namespace mir
++{
++namespace input
++{
++
++/// An interface for listening to a low level stream of touches, in order to provide
++// a "spot" style visualization.
++class TouchVisualizer
++{
++public:
++    virtual ~TouchVisualizer() = default;
++
++    struct Spot
++    {
++        geometry::Point touch_location;
++
++        // If pressure is non-zero, it indicates a press at the spot, as
++        // opposed to a hover.
++        float pressure;
++    };
++
++    virtual void visualize_touches(std::vector<Spot> const& touches) = 0;
++
++protected:
++    TouchVisualizer() = default;
++    TouchVisualizer(const TouchVisualizer&) = delete;
++    TouchVisualizer& operator=(const TouchVisualizer&) = delete;
++};
++
++}
++}
++
++#endif // MIR_INPUT_TOUCH_VISUALIZER_H_
 === modified file 'include/test/mir_test/event_factory.h'
 --- include/test/mir_test/event_factory.h	2014-06-09 18:45:21 +0000
 +++ include/test/mir_test/event_factory.h	2014-08-04 16:03:26 +0000
@@ -19,6 +19,8 @@
  #ifndef MIR_TEST_EVENT_FACTORY_H
  #define MIR_TEST_EVENT_FACTORY_H
++#include "mir/geometry/point.h"
++
  namespace mir
+ {
  namespace input
@@ -78,13 +80,22 @@
  class TouchParameters
+ {
  public:
++    enum class Action
++    {
++        Tap = 0,
++        Move,
++        Release
++    };
++
      TouchParameters();
      TouchParameters& from_device(int device_id);
--    TouchParameters& at_position(int abs_x, int abs_y);
++    TouchParameters& at_position(geometry::Point abs_pos);
++    TouchParameters& with_action(Action touch_action);
      int device_id;
      int abs_x;
      int abs_y;
++    Action action;
  };
  TouchParameters a_touch_event();
 === modified file 'include/test/mir_test/fake_event_hub_input_configuration.h'
 --- include/test/mir_test/fake_event_hub_input_configuration.h	2014-06-02 17:07:02 +0000
 +++ include/test/mir_test/fake_event_hub_input_configuration.h	2014-08-04 16:03:26 +0000
@@ -35,6 +35,7 @@
  namespace input
+ {
  class CursorListener;
++class TouchVisualizer;
  class EventFilter;
  class InputReport;
@@ -55,6 +56,7 @@
          std::shared_ptr<input::InputDispatcher> const& input_dispatcher,
          std::shared_ptr<input::InputRegion> const& input_region,
          std::shared_ptr<input::CursorListener> const& cursor_listener,
++        std::shared_ptr<input::TouchVisualizer> const& touch_visualizer,
          std::shared_ptr<input::InputReport> const& input_report);
      virtual ~FakeEventHubInputConfiguration();
 === added file 'include/test/mir_test_doubles/stub_touch_visualizer.h'
 --- include/test/mir_test_doubles/stub_touch_visualizer.h	1970-01-01 00:00:00 +0000
 +++ include/test/mir_test_doubles/stub_touch_visualizer.h	2014-08-04 16:03:26 +0000
@@ -0,0 +1,43 @@
++/*
++ * 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 warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Robert Carr <robert.carr@canonical.com>
++ */
++
++#ifndef MIR_TEST_DOUBLES_STUB_TOUCH_VISUALIZER_H_
++#define MIR_TEST_DOUBLES_STUB_TOUCH_VISUALIZER_H_
++
++#include "mir/input/touch_visualizer.h"
++
++namespace mir
++{
++namespace test
++{
++namespace doubles
++{
++
++struct StubTouchVisualizer : public input::TouchVisualizer
++{
++    void visualize_touches(std::vector<Spot> const&) override
++    {
++    }
++};
++
++}
++}
++} // namespace mir
++
++#endif // MIR_TEST_DOUBLES_STUB_TOUCH_VISUALIZER_H_
++
 === modified file 'include/test/mir_test_framework/input_testing_server_configuration.h'
 --- include/test/mir_test_framework/input_testing_server_configuration.h	2014-06-23 18:07:24 +0000
 +++ include/test/mir_test_framework/input_testing_server_configuration.h	2014-08-04 16:03:26 +0000
@@ -58,7 +58,7 @@
      InputTestingServerConfiguration();
      explicit InputTestingServerConfiguration(std::vector<geometry::Rectangle> const& display_rects);
--    void exec();
++    void on_start();
      void on_exit();
      std::shared_ptr<mir::input::InputConfiguration> the_input_configuration() override;
 === modified file 'server-ABI-sha1sums'
 --- server-ABI-sha1sums	2014-08-04 16:03:26 +0000
 +++ server-ABI-sha1sums	2014-08-04 16:03:26 +0000
@@ -57,7 +57,7 @@
 bd29f7499f8cbb89e4ba33acf2b72d93592  include/server/mir/compositor/renderer.h
 a839fd0cd5fa469344dc49190ff9d578efc25  include/server/mir/compositor/scene_element.h
 fcf34e424128b87ddc76733594e32e09ebbd486  include/server/mir/compositor/scene.h
--4aa04639e1fd20395aa33ab15c5ce21c60bb79e9  include/server/mir/default_server_configuration.h
++488dcb1e275e32b5dde03cdfdb1538d3694cb8fe  include/server/mir/default_server_configuration.h
  bbb15c910dbc8d7c9a4cc982890486b7e16197e4  include/server/mir/default_server_status_listener.h
 f6cf88826381cd3ec37a6d2179a70093c0bc5  include/server/mir/display_changer.h
  af1ff0714be973ac76d56006a2e5991f68cd1dec  include/server/mir/display_server.h
@@ -86,7 +86,7 @@
 aa4c4db5468d9b9fe8e98a64444538aadd6e17b  include/server/mir/frontend/template_protobuf_message_processor.h
  ba79552edce545fafc9a4f401411c44d0cb3b2cf  include/server/mir/graphics/gl_extensions_base.h
 a0e7922b6c7abe383726a30e17edbee51048  include/server/mir/graphics/surfaceless_egl_context.h
--2997940c93db57b1c4d51b1786ff65503de9d013  include/server/mir/input/android/default_android_input_configuration.h
++36ad5c3d722a5c8f252eb7538a5fb2bff46d2189  include/server/mir/input/android/default_android_input_configuration.h
  f95c2bddf13d15993ef5d6a0ad7b9106ae550b87  include/server/mir/input/composite_event_filter.h
 acb03b35d383dfefd65e8dfb872c42bcc11  include/server/mir/input/cursor_images.h
  c1e96c372d7856d59947f3145d273b1285b569bc  include/server/mir/input/cursor_listener.h
@@ -103,6 +103,7 @@
 cda18e314f1e36177a7ebfab0d1dd12867cdf0  include/server/mir/input/input_send_observer.h
 e757018c337db25df0c68556664eb7536e4321  include/server/mir/input/input_targets.h
 bf95b4512c8b91df7c20edf56a3c0734957  include/server/mir/input/surface.h
++d647ce6beffdc31a597769587bb3ab17ec679491  include/server/mir/input/touch_visualizer.h
 f848c4d63ade96f92a0b8cfc1c33f1ce63  include/server/mir/input/vt_filter.h
 ba863e9bb4dc9802aa74a7864f576df25142c2d  include/server/mir/logging/glog_logger.h
 b241f1e8211386bb8735ee0f752b666949  include/server/mir/main_loop.h
 === modified file 'src/server/input/android/android_input_reader_policy.cpp'
 --- src/server/input/android/android_input_reader_policy.cpp	2014-06-09 18:45:21 +0000
 +++ src/server/input/android/android_input_reader_policy.cpp	2014-08-04 16:03:26 +0000
@@ -26,9 +26,10 @@
  namespace mia = mir::input::android;
  mia::InputReaderPolicy::InputReaderPolicy(std::shared_ptr<mi::InputRegion> const& input_region,
--    std::shared_ptr<CursorListener> const& cursor_listener)
++                                          std::shared_ptr<CursorListener> const& cursor_listener,
++                                          std::shared_ptr<TouchVisualizer> const& touch_visualizer)
      : input_region(input_region),
--      pointer_controller(new mia::PointerController(input_region, cursor_listener))
++      pointer_controller(new mia::PointerController(input_region, cursor_listener, touch_visualizer))
+ {
+ }
@@ -50,6 +51,10 @@
          default_display_orientation);
      out_config->pointerVelocityControlParameters.acceleration = 1.0;
++
++    // This only enables passing through the touch coordinates from the InputReader to the TouchVisualizer
++    // the touch visualizer still decides whether or not to render anything.
++    out_config->showTouches = true;
+ }
  droidinput::sp<droidinput::PointerControllerInterface> mia::InputReaderPolicy::obtainPointerController(int32_t /*device_id*/)
 === modified file 'src/server/input/android/android_input_reader_policy.h'
 --- src/server/input/android/android_input_reader_policy.h	2014-06-09 18:45:21 +0000
 +++ src/server/input/android/android_input_reader_policy.h	2014-08-04 16:03:26 +0000
@@ -28,6 +28,8 @@
+ {
  class CursorListener;
  class InputRegion;
++class TouchVisualizer;
++
  namespace android
+ {
@@ -35,7 +37,8 @@
+ {
  public:
      explicit InputReaderPolicy(std::shared_ptr<InputRegion> const& input_region,
--                               std::shared_ptr<CursorListener> const& cursor_listener);
++                               std::shared_ptr<CursorListener> const& cursor_listener,
++                               std::shared_ptr<TouchVisualizer> const& touch_visualizer);
      virtual ~InputReaderPolicy() {}
 === modified file 'src/server/input/android/android_pointer_controller.cpp'
 --- src/server/input/android/android_pointer_controller.cpp	2013-08-28 03:41:48 +0000
 +++ src/server/input/android/android_pointer_controller.cpp	2014-08-04 16:03:26 +0000
@@ -17,6 +17,7 @@
   */
  #include "mir/input/input_region.h"
++#include "mir/input/touch_visualizer.h"
  #include "mir/geometry/rectangle.h"
  #include "mir/geometry/point.h"
@@ -29,24 +30,15 @@
  namespace geom = mir::geometry;
  mia::PointerController::PointerController(
--    std::shared_ptr<mi::InputRegion> const& input_region)
--        : state(0),
--          x(0.0),
--          y(0.0),
--          input_region(input_region),
--          cursor_listener(std::shared_ptr<mi::CursorListener>())
--{
--}
--
--mia::PointerController::PointerController(
      std::shared_ptr<mi::InputRegion> const& input_region,
--    std::shared_ptr<mi::CursorListener> const& cursor_listener)
++    std::shared_ptr<mi::CursorListener> const& cursor_listener,
++    std::shared_ptr<mi::TouchVisualizer> const& touch_visualizer)
          : state(0),
            x(0.0),
            y(0.0),
            input_region(input_region),
--          cursor_listener(cursor_listener)
--
++          cursor_listener(cursor_listener),
++          touch_visualizer(touch_visualizer)
+ {
+ }
@@ -117,3 +109,25 @@
      *out_x = x;
      *out_y = y;
+ }
++
++void mia::PointerController::setSpots(const droidinput::PointerCoords* spot_coords, uint32_t spot_count)
++{
++    std::vector<mi::TouchVisualizer::Spot> touches;
++    for (uint32_t i = 0; i < spot_count; i++)
++    {
++        droidinput::PointerCoords const& coords = spot_coords[i];
++
++        auto x = coords.getX();
++        auto y = coords.getY();
++        auto pressure = coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE);
++
++        touches.push_back({{x, y}, pressure});
++    }
++
++    touch_visualizer->visualize_touches(touches);
++}
++
++void mia::PointerController::clearSpots()
++{
++    touch_visualizer->visualize_touches({});
++}
 === modified file 'src/server/input/android/android_pointer_controller.h'
 --- src/server/input/android/android_pointer_controller.h	2013-08-28 03:41:48 +0000
 +++ src/server/input/android/android_pointer_controller.h	2014-08-04 16:03:26 +0000
@@ -30,22 +30,27 @@
+ {
  namespace input
+ {
++class TouchVisualizer;
  class InputRegion;
++
  namespace android
+ {
  class PointerController : public DummyPointerController
+ {
    public:
--    explicit PointerController(std::shared_ptr<InputRegion> const& input_region);
      explicit PointerController(std::shared_ptr<InputRegion> const& input_region,
--                               std::shared_ptr<CursorListener> const& cursor_listener);
--
--    virtual bool getBounds(float* out_min_x, float* out_min_y, float* out_max_x, float* out_max_y) const;
--    virtual void move(float delta_x, float delta_y);
--    virtual void setButtonState(int32_t button_state);
--    virtual int32_t getButtonState() const;
--    virtual void setPosition(float x, float y);
--    virtual void getPosition(float *out_x, float *out_y) const;
++        std::shared_ptr<CursorListener> const& cursor_listener,
++        std::shared_ptr<TouchVisualizer> const& touch_visualizer);
++
++    bool getBounds(float* out_min_x, float* out_min_y, float* out_max_x, float* out_max_y) const;
++    void move(float delta_x, float delta_y);
++    void setButtonState(int32_t button_state);
++    int32_t getButtonState() const;
++    void setPosition(float x, float y);
++    void getPosition(float *out_x, float *out_y) const;
++
++    void setSpots(const droidinput::PointerCoords* spot_coords, uint32_t spot_count);
++    void clearSpots();
    private:
      bool get_bounds_locked(float *out_min_x, float* out_min_y, float* out_max_x, float* out_max_y) const;
@@ -57,6 +62,7 @@
      std::shared_ptr<InputRegion> const input_region;
      std::shared_ptr<CursorListener> cursor_listener;
++    std::shared_ptr<TouchVisualizer> const touch_visualizer;
  };
+ }
+ }
 === modified file 'src/server/input/android/default_android_input_configuration.cpp'
 --- src/server/input/android/default_android_input_configuration.cpp	2014-06-24 15:28:09 +0000
 +++ src/server/input/android/default_android_input_configuration.cpp	2014-08-04 16:03:26 +0000
@@ -52,10 +52,12 @@
      std::shared_ptr<mi::InputDispatcher> const& input_dispatcher,
      std::shared_ptr<mi::InputRegion> const& input_region,
      std::shared_ptr<CursorListener> const& cursor_listener,
++    std::shared_ptr<TouchVisualizer> const& touch_visualizer,
      std::shared_ptr<mi::InputReport> const& input_report) :
      input_dispatcher(input_dispatcher),
      input_region(input_region),
      cursor_listener(cursor_listener),
++    touch_visualizer(touch_visualizer),
      input_report(input_report)
+ {
+ }
@@ -78,7 +80,7 @@
      return reader_policy(
          [this]()
+         {
--            return std::make_shared<mia::InputReaderPolicy>(input_region, cursor_listener);
++            return std::make_shared<mia::InputReaderPolicy>(input_region, cursor_listener, touch_visualizer);
          });
+ }
 === modified file 'src/server/input/default_configuration.cpp'
 --- src/server/input/default_configuration.cpp	2014-07-09 10:48:47 +0000
 +++ src/server/input/default_configuration.cpp	2014-08-04 16:03:26 +0000
@@ -38,6 +38,7 @@
  #include "null_input_channel_factory.h"
  #include "mir/input/android/default_android_input_configuration.h"
++#include "mir/input/touch_visualizer.h"
  #include "mir/options/configuration.h"
  #include "mir/options/option.h"
  #include "mir/compositor/scene.h"
@@ -92,6 +93,7 @@
                  the_input_dispatcher(),
                  the_input_region(),
                  the_cursor_listener(),
++                the_touch_visualizer(),
                  the_input_report()
                  );
+         }
@@ -238,6 +240,22 @@
+ }
++std::shared_ptr<mi::TouchVisualizer>
++mir::DefaultServerConfiguration::the_touch_visualizer()
++{
++    struct NullTouchVisualizer : public mi::TouchVisualizer
++    {
++        void visualize_touches(std::vector<Spot> const& /* touches */) override
++        {
++        }
++    };
++    return touch_visualizer(
++        [this]()
++        {
++            return std::make_shared<NullTouchVisualizer>();
++        });
++}
++
  std::shared_ptr<mg::CursorImage>
  mir::DefaultServerConfiguration::the_default_cursor_image()
+ {
 === modified file 'tests/acceptance-tests/CMakeLists.txt'
 --- tests/acceptance-tests/CMakeLists.txt	2014-07-30 15:15:16 +0000
 +++ tests/acceptance-tests/CMakeLists.txt	2014-08-04 16:03:26 +0000
@@ -38,6 +38,7 @@
    test_client_cursor_api.cpp
    test_large_messages.cpp
    test_client_surface_visibility.cpp
++  test_touchspot_visualization.cpp
    test_client_with_custom_display_config_deadlock.cpp
    test_macros.cpp
    test_stale_frames.cpp
 === modified file 'tests/acceptance-tests/test_client_input.cpp'
 --- tests/acceptance-tests/test_client_input.cpp	2014-06-26 16:03:00 +0000
 +++ tests/acceptance-tests/test_client_input.cpp	2014-08-04 16:03:26 +0000
@@ -536,8 +536,8 @@
      server_configuration.produce_events = [&](mtf::InputTestingServerConfiguration& server)
+         {
--            server.fake_event_hub->synthesize_event(mis::a_touch_event().at_position(abs_touch_x_1, abs_touch_y_1));
--            server.fake_event_hub->synthesize_event(mis::a_touch_event().at_position(abs_touch_x_2, abs_touch_y_2));
++            server.fake_event_hub->synthesize_event(mis::a_touch_event().at_position({abs_touch_x_1, abs_touch_y_1}));
++            server.fake_event_hub->synthesize_event(mis::a_touch_event().at_position({abs_touch_x_2, abs_touch_y_2}));
          };
      server_configuration.client_geometries[arbitrary_client_name] = ServerConfiguration::display_bounds;
      start_server();
 === modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
 --- tests/acceptance-tests/test_server_shutdown.cpp	2014-07-21 03:35:31 +0000
 +++ tests/acceptance-tests/test_server_shutdown.cpp	2014-08-04 16:03:26 +0000
@@ -127,7 +127,8 @@
                  std::make_shared<mtd::FakeEventHubInputConfiguration>(
                      the_input_dispatcher(),
                      the_input_region(),
--                    std::shared_ptr<mi::CursorListener>(),
++                    the_cursor_listener(),
++                    the_touch_visualizer(),
                      the_input_report());
+         }
 === added file 'tests/acceptance-tests/test_touchspot_visualization.cpp'
 --- tests/acceptance-tests/test_touchspot_visualization.cpp	1970-01-01 00:00:00 +0000
 +++ tests/acceptance-tests/test_touchspot_visualization.cpp	2014-08-04 16:03:26 +0000
@@ -0,0 +1,222 @@
++/*
++ * 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 warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authored by: Robert Carr <robert.carr@canonical.com>
++ */
++
++#include "mir/input/touch_visualizer.h"
++
++#include "mir_test/fake_event_hub.h"
++#include "mir_test/barrier.h"
++#include "mir_test/fake_shared.h"
++
++#include "mir_test_framework/deferred_in_process_server.h"
++#include "mir_test_framework/input_testing_server_configuration.h"
++
++#include <gtest/gtest.h>
++#include <gmock/gmock.h>
++
++#include <vector>
++#include <functional>
++
++namespace mi = mir::input;
++namespace mis = mi::synthesis;
++namespace mt = mir::test;
++namespace geom = mir::geometry;
++namespace mtf = mir_test_framework;
++
++namespace
++{
++
++ACTION_P(UnblockBarrier, barrier)
++{
++    barrier->ready();
++}
++
++MATCHER(NoSpots, "")
++{
++    if (arg.size() > 0)
++        return false;
++    return true;
++}
++
++static bool
++spots_have_position_and_pressure(std::vector<mi::TouchVisualizer::Spot> const& spots,
++    std::vector<geom::Point> const& positions, float pressure)
++{
++    if (spots.size() != positions.size())
++        return false;
++    auto spots_it = spots.begin();
++    auto positions_it = positions.begin();
++
++    while (spots_it != spots.end())
++    {
++        auto const& spot = *spots_it;
++        if (spot.touch_location != *positions_it)
++            return false;
++        if (spot.pressure != pressure)
++            return false;
++        spots_it++;
++        positions_it++;
++    }
++    return true;
++}
++
++MATCHER_P(TouchedSpotsAt, positions, "")
++{
++    return spots_have_position_and_pressure(arg, positions, 1.0);
++}
++
++struct MockTouchVisualizer : public mi::TouchVisualizer
++{
++    MOCK_METHOD1(visualize_touches, void(std::vector<mi::TouchVisualizer::Spot> const&));
++};
++
++struct ServerConfiguration : mtf::InputTestingServerConfiguration
++{
++    mt::Barrier& test_complete;
++
++    MockTouchVisualizer mock_visualizer;
++
++    std::function<void(mtf::InputTestingServerConfiguration& server)> produce_events;
++    std::function<void(MockTouchVisualizer& visualizer, mt::Barrier& test_complete)> expect_touchspots;
++
++    static geom::Rectangle const display_bounds;
++
++    ServerConfiguration(mt::Barrier& test_complete)
++        : InputTestingServerConfiguration({display_bounds}),
++          test_complete(test_complete)
++    {
++    }
++
++    std::shared_ptr<mi::TouchVisualizer> the_touch_visualizer() override
++    {
++        return mt::fake_shared(mock_visualizer);
++    }
++
++    void inject_input() override
++    {
++        produce_events(*this);
++    }
++
++    void establish_expectations()
++    {
++        // We need to do this before we start the input stack to avoid races
++        // with the initial spot clearing.
++        expect_touchspots(mock_visualizer, test_complete);
++    }
++};
++
++geom::Rectangle const ServerConfiguration::display_bounds = {{0, 0}, {1600, 1600}};
++
++struct TestTouchspotVisualizations : mtf::DeferredInProcessServer
++{
++    mt::Barrier test_complete_fence{2};
++    ServerConfiguration server_configuration{test_complete_fence};
++
++    mir::DefaultServerConfiguration& server_config() override { return server_configuration; }
++
++    void start_server()
++    {
++        server_configuration.establish_expectations();
++
++        DeferredInProcessServer::start_server();
++        server_configuration.exec();
++    }
++
++    void TearDown()
++    {
++        test_complete_fence.ready();
++        server_configuration.on_exit();
++        DeferredInProcessServer::TearDown();
++    }
++};
++
++geom::Point transform_to_screen_space(geom::Point in_touchpad_space)
++{
++    auto minimum_touch = mi::android::FakeEventHub::TouchScreenMinAxisValue;
++    auto maximum_touch = mi::android::FakeEventHub::TouchScreenMaxAxisValue;
++
++    auto display_width = ServerConfiguration::display_bounds.size.width.as_uint32_t();
++    auto display_height = ServerConfiguration::display_bounds.size.height.as_uint32_t();
++
++    float scale_x = float(display_width) / (maximum_touch - minimum_touch + 1);
++    float scale_y = float(display_height) / (maximum_touch - minimum_touch + 1);
++
++    return {scale_x * in_touchpad_space.x.as_uint32_t(), scale_y * in_touchpad_space.y.as_uint32_t()};
++}
++
++}
++
++using namespace ::testing;
++
++TEST_F(TestTouchspotVisualizations, touch_is_given_to_touchspot_visualizer)
++{
++    auto minimum_touch = mi::android::FakeEventHub::TouchScreenMinAxisValue;
++
++    static geom::Point abs_touch = { minimum_touch, minimum_touch };
++    static std::vector<geom::Point> expected_spots = { transform_to_screen_space(abs_touch) };
++
++    server_configuration.produce_events = [&](mtf::InputTestingServerConfiguration& server)
++        {
++            server.fake_event_hub->synthesize_event(mis::a_touch_event().at_position(abs_touch));
++            server.fake_event_hub->synthesize_event(mis::a_touch_event().at_position(abs_touch)
++                .with_action(mis::TouchParameters::Action::Release));
++        };
++    server_configuration.expect_touchspots = [&](MockTouchVisualizer &visualizer, mt::Barrier& test_complete)
++        {
++            InSequence seq;
++
++            // First we will see the spots cleared, as this is the start of a new gesture.
++            EXPECT_CALL(visualizer, visualize_touches(NoSpots())).Times(1);
++            EXPECT_CALL(visualizer, visualize_touches(TouchedSpotsAt(expected_spots)));
++            EXPECT_CALL(visualizer, visualize_touches(NoSpots())).Times(1).
++                WillOnce(UnblockBarrier(&test_complete));
++        };
++    start_server();
++}
++
++TEST_F(TestTouchspotVisualizations, touchspots_follow_gesture)
++{
++    auto minimum_touch = mi::android::FakeEventHub::TouchScreenMinAxisValue;
++    auto maximum_touch = mi::android::FakeEventHub::TouchScreenMaxAxisValue;
++
++    static geom::Point abs_touch = { minimum_touch, minimum_touch };
++    static geom::Point abs_touch_2 = { maximum_touch, maximum_touch };
++    static std::vector<geom::Point> expected_spots_1 =
++       { transform_to_screen_space(abs_touch) };
++    static std::vector<geom::Point> expected_spots_2 =
++       { transform_to_screen_space(abs_touch_2) };
++
++    server_configuration.produce_events = [&](mtf::InputTestingServerConfiguration& server)
++        {
++            server.fake_event_hub->synthesize_event(mis::a_touch_event().at_position(abs_touch));
++            server.fake_event_hub->synthesize_event(mis::a_touch_event().at_position(abs_touch_2)
++                .with_action(mis::TouchParameters::Action::Move));
++            server.fake_event_hub->synthesize_event(mis::a_touch_event().at_position(abs_touch_2)
++                .with_action(mis::TouchParameters::Action::Release));
++        };
++    server_configuration.expect_touchspots = [&](MockTouchVisualizer &visualizer, mt::Barrier& test_complete)
++        {
++            InSequence seq;
++
++            EXPECT_CALL(visualizer, visualize_touches(NoSpots())).Times(1);
++            EXPECT_CALL(visualizer, visualize_touches(TouchedSpotsAt(expected_spots_1))).Times(1);
++            EXPECT_CALL(visualizer, visualize_touches(TouchedSpotsAt(expected_spots_2))).Times(1);
++            EXPECT_CALL(visualizer, visualize_touches(NoSpots())).
++                Times(1).WillOnce(UnblockBarrier(&test_complete));
++        };
++    start_server();
++}
 === modified file 'tests/integration-tests/input/android/test_android_cursor_listener.cpp'
 --- tests/integration-tests/input/android/test_android_cursor_listener.cpp	2014-06-03 11:04:15 +0000
 +++ tests/integration-tests/input/android/test_android_cursor_listener.cpp	2014-08-04 16:03:26 +0000
@@ -36,6 +36,7 @@
  #include "mir_test/fake_event_hub_input_configuration.h"
  #include "mir_test_doubles/mock_event_filter.h"
  #include "mir_test_doubles/stub_input_enumerator.h"
++#include "mir_test_doubles/stub_touch_visualizer.h"
  #include "mir_test/wait_condition.h"
  #include "mir_test/event_factory.h"
@@ -97,6 +98,7 @@
              mt::fake_shared(dispatcher),
              mt::fake_shared(input_region),
              mt::fake_shared(cursor_listener),
++            mt::fake_shared(touch_visualizer),
              null_report);
          fake_event_hub = configuration->the_fake_event_hub();
@@ -117,6 +119,7 @@
      mia::FakeEventHub* fake_event_hub;
      std::shared_ptr<mi::InputManager> input_manager;
      MockCursorListener cursor_listener;
++    mtd::StubTouchVisualizer touch_visualizer;
      StubInputRegion input_region;
  };
 === modified file 'tests/integration-tests/input/android/test_android_input_manager.cpp'
 --- tests/integration-tests/input/android/test_android_input_manager.cpp	2014-06-03 11:04:15 +0000
 +++ tests/integration-tests/input/android/test_android_input_manager.cpp	2014-08-04 16:03:26 +0000
@@ -41,6 +41,7 @@
  #include "mir_test_doubles/stub_input_targets.h"
  #include "mir_test_doubles/stub_scene.h"
  #include "mir_test_doubles/stub_input_enumerator.h"
++#include "mir_test_doubles/stub_touch_visualizer.h"
  #include "mir_test/wait_condition.h"
  #include "mir_test/event_factory.h"
  #include "mir_test/event_matchers.h"
@@ -107,6 +108,7 @@
                  mt::fake_shared(dispatcher),
                  mt::fake_shared(input_region),
                  null_cursor_listener,
++                mt::fake_shared(touch_visualizer),
                  mr::null_input_report());
          fake_event_hub = configuration->the_fake_event_hub();
@@ -128,6 +130,7 @@
      mia::FakeEventHub* fake_event_hub;
      std::shared_ptr<mi::InputManager> input_manager;
      StubInputRegion input_region;
++    mtd::StubTouchVisualizer touch_visualizer;
  };
+ }
@@ -268,7 +271,8 @@
+     {
          input_registrar->set_dispatcher(android_dispatcher);
          configuration = std::make_shared<mtd::FakeEventHubInputConfiguration>(
--            mt::fake_shared(dispatcher), mt::fake_shared(input_region), null_cursor_listener, null_report);
++            mt::fake_shared(dispatcher), mt::fake_shared(input_region), null_cursor_listener,
++            std::make_shared<mtd::StubTouchVisualizer>(), null_report);
          fake_event_hub = configuration->the_fake_event_hub();
          input_manager = configuration->the_input_manager();
 === modified file 'tests/mir_test_doubles/event_factory.cpp'
 --- tests/mir_test_doubles/event_factory.cpp	2014-06-09 18:45:21 +0000
 +++ tests/mir_test_doubles/event_factory.cpp	2014-08-04 16:03:26 +0000
@@ -18,6 +18,7 @@
  #include "mir_test/event_factory.h"
  namespace mis = mir::input::synthesis;
++namespace geom = mir::geometry;
  mis::KeyParameters::KeyParameters() :
      device_id(0),
@@ -117,7 +118,8 @@
  mis::TouchParameters::TouchParameters() :
      device_id(0),
      abs_x(0),
--    abs_y(0)
++    abs_y(0),
++    action(Action::Tap)
+ {
+ }
@@ -127,10 +129,16 @@
      return *this;
+ }
--mis::TouchParameters& mis::TouchParameters::at_position(int new_abs_x, int new_abs_y)
--{
--    abs_x = new_abs_x;
--    abs_y = new_abs_y;
++mis::TouchParameters& mis::TouchParameters::at_position(geom::Point abs_pos)
++{
++    abs_x = abs_pos.x.as_int();
++    abs_y = abs_pos.y.as_int();
++    return *this;
++}
++
++mis::TouchParameters& mis::TouchParameters::with_action(Action touch_action)
++{
++    action = touch_action;
      return *this;
+ }
 === modified file 'tests/mir_test_doubles/fake_event_hub.cpp'
 --- tests/mir_test_doubles/fake_event_hub.cpp	2014-06-09 18:45:21 +0000
 +++ tests/mir_test_doubles/fake_event_hub.cpp	2014-08-04 16:03:26 +0000
@@ -571,11 +571,14 @@
      event.code = ABS_Y;
      event.value = parameters.abs_y;
      events_available.push_back(event);
--
--    event.type = EV_KEY;
--    event.code = BTN_TOUCH;
--    event.value = 1;
--    events_available.push_back(event);
++
++    if (parameters.action != mis::TouchParameters::Action::Move)
++    {
++        event.type = EV_KEY;
++        event.code = BTN_TOUCH;
++        event.value = (parameters.action == mis::TouchParameters::Action::Tap);
++        events_available.push_back(event);
++    }
      // Cursor motion events require a sync as per droidinput::CursorInputMapper::process
      event.type = EV_SYN;
 === modified file 'tests/mir_test_doubles/fake_event_hub_input_configuration.cpp'
 --- tests/mir_test_doubles/fake_event_hub_input_configuration.cpp	2014-06-02 17:07:02 +0000
 +++ tests/mir_test_doubles/fake_event_hub_input_configuration.cpp	2014-08-04 16:03:26 +0000
@@ -28,8 +28,9 @@
      std::shared_ptr<mir::input::InputDispatcher> const& dispatcher,
      std::shared_ptr<input::InputRegion> const& input_region,
      std::shared_ptr<input::CursorListener> const& cursor_listener,
++    std::shared_ptr<input::TouchVisualizer> const& touch_visualizer,
      std::shared_ptr<mi::InputReport> const& input_report) :
--    DefaultInputConfiguration(dispatcher, input_region, cursor_listener, input_report),
++    DefaultInputConfiguration(dispatcher, input_region, cursor_listener, touch_visualizer, input_report),
      event_hub(std::make_shared<mia::FakeEventHub>())
+ {
+ }
 === modified file 'tests/mir_test_framework/input_testing_server_options.cpp'
 --- tests/mir_test_framework/input_testing_server_options.cpp	2014-06-23 22:25:17 +0000
 +++ tests/mir_test_framework/input_testing_server_options.cpp	2014-08-04 16:03:26 +0000
@@ -53,7 +53,7 @@
+ {
+ }
--void mtf::InputTestingServerConfiguration::exec()
++void mtf::InputTestingServerConfiguration::on_start()
+ {
      input_injection_thread = std::thread(std::mem_fn(&mtf::InputTestingServerConfiguration::inject_input), this);
+ }
@@ -86,6 +86,7 @@
              the_input_dispatcher(),
              the_input_region(),
              the_cursor_listener(),
++            the_touch_visualizer(),
              the_input_report());
          fake_event_hub = input_configuration->the_fake_event_hub();
 === modified file 'tests/unit-tests/input/android/test_android_input_reader_policy.cpp'
 --- tests/unit-tests/input/android/test_android_input_reader_policy.cpp	2013-08-28 03:41:48 +0000
 +++ tests/unit-tests/input/android/test_android_input_reader_policy.cpp	2014-08-04 16:03:26 +0000
@@ -17,6 +17,7 @@
   */
  #include "mir_test_doubles/mock_input_region.h"
++#include "mir_test_doubles/stub_touch_visualizer.h"
  #include "mir_test/fake_shared.h"
  #include "src/server/input/android/android_input_reader_policy.h"
@@ -45,7 +46,8 @@
+     {
          reader_policy = std::make_shared<mia::InputReaderPolicy>(
              mt::fake_shared(input_region),
--            std::shared_ptr<mi::CursorListener>());
++            std::shared_ptr<mi::CursorListener>(),
++            std::make_shared<mtd::StubTouchVisualizer>());
          ON_CALL(input_region, bounding_rectangle()).WillByDefault(Return(default_view_area));
+     }
 === modified file 'tests/unit-tests/input/android/test_android_pointer_controller.cpp'
 --- tests/unit-tests/input/android/test_android_pointer_controller.cpp	2013-08-28 03:41:48 +0000
 +++ tests/unit-tests/input/android/test_android_pointer_controller.cpp	2014-08-04 16:03:26 +0000
@@ -19,6 +19,7 @@
  #include "src/server/input/android/android_pointer_controller.h"
  #include "mir_test_doubles/mock_input_region.h"
++#include "mir_test_doubles/stub_touch_visualizer.h"
  #include "mir_test/event_factory.h"
  #include "mir_test/fake_shared.h"
@@ -45,7 +46,8 @@
  public:
      void SetUp()
+     {
--        controller = std::make_shared<mia::PointerController>(mt::fake_shared(input_region));
++        controller = std::make_shared<mia::PointerController>(mt::fake_shared(input_region), std::shared_ptr<mi::CursorListener>(),
++                                                              std::make_shared<mtd::StubTouchVisualizer>());
+     }
  protected:
      mtd::MockInputRegion input_region;