Mir

Merge lp:~andreas-pokorny/mir/fix-1531517 into lp:mir

fix-1531517
Merge into development-branch

Proposed by Andreas Pokorny on 2016-01-13

Status:

Merged

Approved by:

Alexandros Frantzis on 2016-01-15

Approved revision:

3245

Merged at revision:

3243

Proposed branch:

lp:~andreas-pokorny/mir/fix-1531517

Merge into:

lp:mir

Diff against target:

362 lines (+241/-44)

2 files modified

src/server/input/android/input_sender.cpp (+69/-28)
tests/unit-tests/input/android/test_android_input_sender.cpp (+172/-16)

To merge this branch:

bzr merge lp:~andreas-pokorny/mir/fix-1531517

Critical

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Approve on 2016-01-15
Mir CI Bot	continuous-integration		Approve on 2016-01-15
Brandon Schaefer (community)			Approve on 2016-01-15
Kevin DuBois (community)			Approve on 2016-01-14
Alexandros Frantzis (community)		2016-01-13	Approve on 2016-01-14
Review via email: mp+282439@code.launchpad.net

Commit Message

Never encode more than one action per event

Android InputTransport has only one action parameter per event. Within that the contact that caused the action is also encoded. So until we replace or extend the input transport protocol, we have to split up MirEvents, to not lose touch up/down changes.

Description of the Change

This change splits a MirEvent into several input transport messages when more than one contact was changed.

Alternatively to this approach we could 'just' change the InputTransport protocol... But I would wait with that when bschaefer gets around to add the cookie.. Additionally Daniel D'Andrada indicated that qt might not like seeing multiple state changes, at least there was some uncertainty.

PS Jenkins bot (ps-jenkins) wrote on 2016-01-13:

FAILED: Continuous integration, rev:3241
http://jenkins.qa.ubuntu.com/job/mir-ci/6001/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/5514/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/4421
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/5470/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-xenial-amd64-ci/325
        deb: http://jenkins.qa.ubuntu.com/job/mir-xenial-amd64-ci/325/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-xenial-i386-ci/325
        deb: http://jenkins.qa.ubuntu.com/job/mir-xenial-i386-ci/325/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/5467/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/6001/rebuild

review: Needs Fixing (continuous-integration)

lp:~andreas-pokorny/mir/fix-1531517 updated on 2016-01-13

3242. By Andreas Pokorny on 2016-01-13: fix MirCookie init in test case

Alexandros Frantzis (afrantzis) wrote on 2016-01-13:

I find it hard to follow the logic in the main loop, although this could just be a result of my unfamiliarity with the domain. Perhaps breaking up the code into multiple distinct passes over the touch points, each pass performing a simple task and setting up state for the next pass, would make the code clearer.

I don't see anything wrong with the code, but I am not confident enough to "approve" either, so "abstain" :)

review: Abstain

Mir CI Bot (mir-ci-bot) wrote on 2016-01-13:

PASSED: Continuous integration, rev:3241
https://mir-jenkins.ubuntu.com/job/mir-ci/37/
Executed test runs:
None: https://mir-jenkins.ubuntu.com/job/generic-update-mp/37/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/37/rebuild

review: Approve (continuous-integration)

Andreas Pokorny (andreas-pokorny) wrote on 2016-01-13:

> I find it hard to follow the logic in the main loop, although this could just
> be a result of my unfamiliarity with the domain. Perhaps breaking up the code
> into multiple distinct passes over the touch points, each pass performing a
> simple task and setting up state for the next pass, would make the code
> clearer.
>
> I don't see anything wrong with the code, but I am not confident enough to
> "approve" either, so "abstain" :)

fair enough.
Hm I cannot see a simple solution .. I have three types up:
* up contacts have to be sent as change events until they have been processed then they have to be ignored.
* change contact are added always
* down contacts have to be omitted until they get processed.. then they have to be sent as change contacts..

ah.. yeah i guess that could turn into simpler code. Will give it a try.

Mir CI Bot (mir-ci-bot) wrote on 2016-01-13:

PASSED: Continuous integration, rev:3242
https://mir-jenkins.ubuntu.com/job/mir-ci/38/
Executed test runs:
None: https://mir-jenkins.ubuntu.com/job/generic-update-mp/38/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/38/rebuild

review: Approve (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2016-01-13:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/6002/rebuild

review: Approve (continuous-integration)

lp:~andreas-pokorny/mir/fix-1531517 updated on 2016-01-14

3243. By Andreas Pokorny on 2016-01-14: Reduced loop state a lot, by encoding the state changes in a separate array
3244. By Andreas Pokorny on 2016-01-14: lambda not needed either..

Mir CI Bot (mir-ci-bot) wrote on 2016-01-14:

PASSED: Continuous integration, rev:3243
https://mir-jenkins.ubuntu.com/job/mir-ci/50/
Executed test runs:
None: https://mir-jenkins.ubuntu.com/job/generic-update-mp/50/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/50/rebuild

review: Approve (continuous-integration)

Alexandros Frantzis (afrantzis) wrote on 2016-01-14:

OK. I am still missing some domain knowledge about why things are done this way, but the code is clearer. Thanks.

review: Approve

Mir CI Bot (mir-ci-bot) wrote on 2016-01-14:

PASSED: Continuous integration, rev:3244
https://mir-jenkins.ubuntu.com/job/mir-ci/51/
Executed test runs:
None: https://mir-jenkins.ubuntu.com/job/generic-update-mp/51/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/51/rebuild

review: Approve (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2016-01-14:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/6015/rebuild

review: Approve (continuous-integration)

Brandon Schaefer (brandontschaefer) wrote on 2016-01-14:

LGTM. For my changes ill just be hard coding an uint8_t[20] for the mac, sooo this wont cause me any issues. Which will just give me a operator= copy/move for the mac anyway soo no fancy changes needed on my end here.

Sooo really depends on whos branch lands first :), should be a simple conflict (if any)

One things:
+#include <unordered_set>
+ std::unordered_set<size_t> sent_indices;

Doesnt seem to be used?

PS Jenkins bot (ps-jenkins) wrote on 2016-01-14:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/6016/rebuild

review: Approve (continuous-integration)

Kevin DuBois (kdub) wrote on 2016-01-14:

lgtm

review: Approve

lp:~andreas-pokorny/mir/fix-1531517 updated on 2016-01-14

3245. By Andreas Pokorny on 2016-01-14: unused variable removed:

Andreas Pokorny (andreas-pokorny) wrote on 2016-01-14:

> LGTM. For my changes ill just be hard coding an uint8_t[20] for the mac, sooo
> this wont cause me any issues. Which will just give me a operator= copy/move
> for the mac anyway soo no fancy changes needed on my end here.
>
> Sooo really depends on whos branch lands first :), should be a simple conflict
> (if any)
>
> One things:
> +#include <unordered_set>
> + std::unordered_set<size_t> sent_indices;
>
> Doesnt seem to be used?

yes removed that

Brandon Schaefer (brandontschaefer) wrote on 2016-01-15:

LGTM

review: Approve

Mir CI Bot (mir-ci-bot) wrote on 2016-01-15:

PASSED: Continuous integration, rev:3245
https://mir-jenkins.ubuntu.com/job/mir-ci/62/
Executed test runs:
None: https://mir-jenkins.ubuntu.com/job/generic-update-mp/62/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/62/rebuild

review: Approve (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2016-01-15:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/6026/rebuild

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:

Andreas Pokorny

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'src/server/input/android/input_sender.cpp'
 --- src/server/input/android/input_sender.cpp	2016-01-08 09:20:07 +0000
 +++ src/server/input/android/input_sender.cpp	2016-01-14 23:05:33 +0000
@@ -254,40 +254,81 @@
  droidinput::status_t mia::InputSender::ActiveTransfer::send_touch_event(uint32_t seq, MirEvent const& event)
+ {
++    droidinput::status_t ret = droidinput::OK;
      droidinput::PointerCoords coords[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
      droidinput::PointerProperties properties[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
--    std::memset(&coords, 0, sizeof(coords));
--    std::memset(&properties, 0, sizeof(properties));
--
      auto input_event = mir_event_get_input_event(&event);
      auto touch = mir_input_event_get_touch_event(input_event);
++    std::chrono::nanoseconds const event_time{mir_input_event_get_event_time(input_event)};
++    auto const x_offset = 0.0f;
++    auto const y_offset = 0.0f;
++    auto const x_precision = 0;
++    auto const y_precision = 0;
++    auto const flags = 0;
++    auto const edge_flags = 0;
++    auto const button_state = 0;
++
++    struct StateChange
++    {
++        int android_action;
++        size_t index;
++    };
++
++    std::vector<StateChange> state_changes;
      for (size_t i = 0, e = mir_touch_event_point_count(touch); i != e; ++i)
+     {
--        // Note: this assumes that: x == raw_x + x_offset;
--        // here x, y is used instead of the raw co-ordinates and offset is set to zero
--        coords[i].setAxisValue(AMOTION_EVENT_AXIS_X, mir_touch_event_axis_value(touch, i, mir_touch_axis_x));
--        coords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, mir_touch_event_axis_value(touch, i, mir_touch_axis_y));
--        coords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, mir_touch_event_axis_value(touch, i, mir_touch_axis_touch_major));
--        coords[i].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, mir_touch_event_axis_value(touch, i, mir_touch_axis_touch_minor));
--        coords[i].setAxisValue(AMOTION_EVENT_AXIS_SIZE, mir_touch_event_axis_value(touch, i, mir_touch_axis_size));
--        coords[i].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, mir_touch_event_axis_value(touch, i, mir_touch_axis_pressure));
--        properties[i].toolType = mia::android_tool_type_from_mir(mir_touch_event_tooltype(touch, i));
--        properties[i].id = mir_touch_event_id(touch, i);
--    }
--
--    std::chrono::nanoseconds const event_time{mir_input_event_get_event_time(input_event)};
--    auto const x_offset = 0.0f;
--    auto const y_offset = 0.0f;
--    auto const x_precision = 0;
--    auto const y_precision = 0;
--    auto const flags = 0;
--    auto const edge_flags = 0;
--    auto const button_state = 0;
--    return publisher.publishMotionEvent(seq, mir_input_event_get_device_id(input_event), AINPUT_SOURCE_TOUCHSCREEN,
--                                        mia::extract_android_action_from(event), flags, edge_flags,
--                                        mia::android_modifiers_from_mir(mir_touch_event_modifiers(touch)), button_state,
--                                        x_offset, y_offset, x_precision, y_precision, event.motion.mac, event_time,
--                                        event_time, mir_touch_event_point_count(touch), properties, coords);
++        auto const action = mir_touch_event_action(touch, i);
++        if (action == mir_touch_action_down)
++            state_changes.push_back(StateChange{AMOTION_EVENT_ACTION_DOWN, i});
++        if (action == mir_touch_action_up)
++            state_changes.push_back(StateChange{AMOTION_EVENT_ACTION_UP, i});
++    }
++
++    if (state_changes.empty())
++        state_changes.push_back(StateChange{AMOTION_EVENT_ACTION_MOVE, 0});
++
++    for (auto state_change : state_changes)
++    {
++        std::memset(&coords, 0, sizeof(coords));
++        std::memset(&properties, 0, sizeof(properties));
++
++        int contacts_in_event = 0;
++        int action_index = 0;
++        for (size_t i = 0, e = mir_touch_event_point_count(touch); i != e; ++i)
++        {
++            auto const action = mir_touch_event_action(touch, i);
++
++            if (i == state_change.index)
++                action_index = contacts_in_event;
++
++            // before a touch up state change got processed it is treated as 'change', skipped otherwise
++            // after a touch down state change got processed it is treated as 'change', skipped otherwise
++            if (i == state_change.index
++                || (i < state_change.index && action != mir_touch_action_up)
++                || (i > state_change.index && action != mir_touch_action_down))
++            {
++                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_X, mir_touch_event_axis_value(touch, i, mir_touch_axis_x));
++                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_Y, mir_touch_event_axis_value(touch, i, mir_touch_axis_y));
++                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, mir_touch_event_axis_value(touch, i, mir_touch_axis_touch_major));
++                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, mir_touch_event_axis_value(touch, i, mir_touch_axis_touch_minor));
++                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_SIZE, mir_touch_event_axis_value(touch, i, mir_touch_axis_size));
++                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, mir_touch_event_axis_value(touch, i, mir_touch_axis_pressure));
++                properties[contacts_in_event].toolType = mia::android_tool_type_from_mir(mir_touch_event_tooltype(touch, i));
++                properties[contacts_in_event].id = mir_touch_event_id(touch, i);
++                ++contacts_in_event;
++            }
++        }
++
++        state_change.android_action |= (action_index << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
++
++        ret = publisher.publishMotionEvent(seq, mir_input_event_get_device_id(input_event), AINPUT_SOURCE_TOUCHSCREEN,
++                                           state_change.android_action, flags, edge_flags,
++                                           mia::android_modifiers_from_mir(mir_touch_event_modifiers(touch)),
++                                           button_state, x_offset, y_offset, x_precision, y_precision, event.motion.mac,
++                                           event_time, event_time, contacts_in_event, properties, coords);
++    }
++
++    return ret;
+ }
  droidinput::status_t mia::InputSender::ActiveTransfer::send_pointer_event(uint32_t seq, MirEvent const& event)
 === modified file 'tests/unit-tests/input/android/test_android_input_sender.cpp'
 --- tests/unit-tests/input/android/test_android_input_sender.cpp	2016-01-08 09:20:07 +0000
 +++ tests/unit-tests/input/android/test_android_input_sender.cpp	2016-01-14 23:05:33 +0000
@@ -17,10 +17,10 @@
   */
  #include "mir/events/event_private.h"
--#include "mir/events/event_builders.h"
  #include "src/server/input/android/android_input_channel.h"
  #include "src/server/input/android/input_sender.h"
++#include "src/server/input/default_event_builder.h"
  #include "src/server/report/null_report_factory.h"
  #include "mir/test/doubles/stub_scene_surface.h"
@@ -35,6 +35,7 @@
  #include "androidfw/InputTransport.h"
  #include "mir/input/input_report.h"
++#include "mir/cookie_factory.h"
  #include <gtest/gtest.h>
  #include <gmock/gmock.h>
@@ -47,7 +48,6 @@
  namespace mi = mir::input;
  namespace ms = mir::scene;
  namespace mia = mi::android;
--namespace mev = mir::events;
  namespace mt = mir::test;
  namespace mr = mir::report;
  namespace mtd = mt::doubles;
@@ -90,6 +90,14 @@
      std::shared_ptr<ms::Observer> observer;
  };
++class StubCookieFactory : public mir::cookie::CookieFactory
++{
++public:
++    MirCookie timestamp_to_cookie(uint64_t const&) override { return {0, 0};}
++    bool attest_timestamp(MirCookie const&) override {return true;}
++    StubCookieFactory() = default;
++};
++
+ }
  class AndroidInputSender : public ::testing::Test
@@ -99,26 +107,29 @@
      size_t const test_pointer_count = 2;
      float const test_x_coord[2] = {12, 23};
      float const test_y_coord[2] = {17, 9};
--    mir::geometry::Point const pos{100, 100};
++    MirTouchTooltype const tool = mir_touch_tooltype_finger;
++    float const pressure = 0.6f;
++    float const major = 8;
++    float const minor = 4;
++    float const size = 8;
      mir::geometry::Displacement const movement{10, -10};
++    StubCookieFactory cookie_factory;
++    mi::DefaultEventBuilder builder{MirInputDeviceId(), mt::fake_shared(cookie_factory)};
      AndroidInputSender()
--        : key_event(mev::make_event(MirInputDeviceId(), std::chrono::nanoseconds(1), 0, mir_keyboard_action_down, 7,
--                                    test_scan_code, mir_input_event_modifier_none)),
--          motion_event(
--              mev::make_event(MirInputDeviceId(), std::chrono::nanoseconds(-1), 0, mir_input_event_modifier_none)),
--          pointer_event(mev::make_event(MirInputDeviceId(), std::chrono::nanoseconds(123), 0,
--                                        mir_input_event_modifier_none, mir_pointer_action_motion,
--                                        mir_pointer_button_primary, pos.x.as_float(), pos.y.as_float(), 0.0f, 0.0f,
++        : key_event(builder.key_event(std::chrono::nanoseconds(1), mir_keyboard_action_down, 7, test_scan_code)),
++          motion_event(builder.touch_event(std::chrono::nanoseconds(-1))),
++          pointer_event(builder.pointer_event(std::chrono::nanoseconds(123), mir_pointer_action_motion,
++                                        mir_pointer_button_primary, 0.0f, 0.0f,
                                          movement.dx.as_float(), movement.dy.as_float()))
+     {
          using namespace ::testing;
--        mev::add_touch(*motion_event, 0, mir_touch_action_change, mir_touch_tooltype_finger, test_x_coord[0], test_y_coord[0],
--                       24, 25, 26, 27);
--        mev::add_touch(*motion_event, 1, mir_touch_action_change, mir_touch_tooltype_finger, test_x_coord[1], test_y_coord[1],
--                       24, 25, 26, 27);
++        builder.add_touch(*motion_event, 0, mir_touch_action_change, tool, test_x_coord[0], test_y_coord[0],
++                       pressure, major, minor, size);
++        builder.add_touch(*motion_event, 1, mir_touch_action_change, tool, test_x_coord[1], test_y_coord[1],
++                       pressure, major, minor, size);
          ON_CALL(event_factory, createKeyEvent()).WillByDefault(Return(&client_key_event));
          ON_CALL(event_factory, createMotionEvent()).WillByDefault(Return(&client_motion_event));
@@ -293,8 +304,6 @@
      EXPECT_EQ(1, client_motion_event.getPointerCount());
--    EXPECT_EQ(pos.x.as_float(), client_motion_event.getX(0));
--    EXPECT_EQ(pos.y.as_float(), client_motion_event.getY(0));
      EXPECT_EQ(movement.dx.as_float(), client_motion_event.getAxisValue(AMOTION_EVENT_AXIS_RX, 0));
      EXPECT_EQ(movement.dy.as_float(), client_motion_event.getAxisValue(AMOTION_EVENT_AXIS_RY, 0));
      EXPECT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, client_motion_event.getToolType(0));
@@ -339,3 +348,150 @@
      consumer.sendFinishedSignal(seq, false);
      loop.trigger_pending_fds();
+ }
++
++TEST_F(AndroidInputSender, encodes_multiple_touch_contact_downs_as_multiple_events)
++{
++    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
++    register_surface();
++
++    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
++    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_down, tool, 50, 60, pressure, major, minor, size);
++    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_down, tool, 80, 90, pressure, major, minor, size);
++
++    sender.send_event(*touch_ev_with_simultaneous_down, channel);
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
++    EXPECT_EQ(0, client_motion_event.getActionIndex());
++    EXPECT_EQ(2, client_motion_event.getPointerId(0));
++    EXPECT_EQ(1, client_motion_event.getPointerCount());
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
++    EXPECT_EQ(1, client_motion_event.getActionIndex());
++    EXPECT_EQ(2, client_motion_event.getPointerId(0));
++    EXPECT_EQ(4, client_motion_event.getPointerId(1));
++    EXPECT_EQ(2, client_motion_event.getPointerCount());
++}
++
++TEST_F(AndroidInputSender, encodes_multiple_touch_contact_downs_as_multiple_events_but_keeps_only_moved_contacts_in_place)
++{
++    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
++    register_surface();
++
++    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
++    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_down, tool, 50, 60, pressure, major, minor, size);
++    builder.add_touch(*touch_ev_with_simultaneous_down, 3, mir_touch_action_change, tool, 10, 10, pressure, major, minor, size);
++    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_down, tool, 80, 90, pressure, major, minor, size);
++
++    sender.send_event(*touch_ev_with_simultaneous_down, channel);
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
++    EXPECT_EQ(0, client_motion_event.getActionIndex());
++    EXPECT_EQ(2, client_motion_event.getPointerId(0));
++    EXPECT_EQ(3, client_motion_event.getPointerId(1));
++    EXPECT_EQ(2, client_motion_event.getPointerCount());
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
++    EXPECT_EQ(2, client_motion_event.getActionIndex());
++    EXPECT_EQ(2, client_motion_event.getPointerId(0));
++    EXPECT_EQ(3, client_motion_event.getPointerId(1));
++    EXPECT_EQ(4, client_motion_event.getPointerId(2));
++    EXPECT_EQ(3, client_motion_event.getPointerCount());
++}
++
++TEST_F(AndroidInputSender, encodes_multiple_releases_in_several_events)
++{
++    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
++    register_surface();
++
++    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
++    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_up, tool, 50, 60, pressure, major, minor, size);
++    builder.add_touch(*touch_ev_with_simultaneous_down, 3, mir_touch_action_change, tool, 10, 10, pressure, major, minor, size);
++    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_up, tool, 80, 90, pressure, major, minor, size);
++
++    sender.send_event(*touch_ev_with_simultaneous_down, channel);
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_UP, client_motion_event.getActionMasked());
++    EXPECT_EQ(0, client_motion_event.getActionIndex());
++    EXPECT_EQ(2, client_motion_event.getPointerId(0));
++    EXPECT_EQ(3, client_motion_event.getPointerId(1));
++    EXPECT_EQ(4, client_motion_event.getPointerId(2));
++    EXPECT_EQ(3, client_motion_event.getPointerCount());
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_UP, client_motion_event.getActionMasked());
++    EXPECT_EQ(1, client_motion_event.getActionIndex());
++    EXPECT_EQ(3, client_motion_event.getPointerId(0));
++    EXPECT_EQ(4, client_motion_event.getPointerId(1));
++    EXPECT_EQ(2, client_motion_event.getPointerCount());
++}
++
++TEST_F(AndroidInputSender, encodes_combinations_of_up_and_down_one_by_one)
++{
++    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
++    register_surface();
++
++    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
++    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_up, tool, 50, 60, pressure, major, minor, size);
++    builder.add_touch(*touch_ev_with_simultaneous_down, 3, mir_touch_action_change, tool, 10, 10, pressure, major, minor, size);
++    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_down, tool, 80, 90, pressure, major, minor, size);
++
++    sender.send_event(*touch_ev_with_simultaneous_down, channel);
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_UP, client_motion_event.getActionMasked());
++    EXPECT_EQ(0, client_motion_event.getActionIndex());
++    EXPECT_EQ(2, client_motion_event.getPointerId(0));
++    EXPECT_EQ(3, client_motion_event.getPointerId(1));
++    EXPECT_EQ(2, client_motion_event.getPointerCount());
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
++    EXPECT_EQ(1, client_motion_event.getActionIndex());
++    EXPECT_EQ(3, client_motion_event.getPointerId(0));
++    EXPECT_EQ(4, client_motion_event.getPointerId(1));
++    EXPECT_EQ(2, client_motion_event.getPointerCount());
++}
++
++TEST_F(AndroidInputSender, encodes_combinations_of_down_and_up_one_by_one)
++{
++    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
++    register_surface();
++
++    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
++    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_down, tool, 50, 60, pressure, major, minor, size);
++    builder.add_touch(*touch_ev_with_simultaneous_down, 3, mir_touch_action_change, tool, 10, 10, pressure, major, minor, size);
++    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_up, tool, 80, 90, pressure, major, minor, size);
++
++    sender.send_event(*touch_ev_with_simultaneous_down, channel);
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
++    EXPECT_EQ(0, client_motion_event.getActionIndex());
++    EXPECT_EQ(2, client_motion_event.getPointerId(0));
++    EXPECT_EQ(3, client_motion_event.getPointerId(1));
++    EXPECT_EQ(4, client_motion_event.getPointerId(2));
++    EXPECT_EQ(3, client_motion_event.getPointerCount());
++
++    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
++    EXPECT_EQ(&client_motion_event, event);
++    EXPECT_EQ(AMOTION_EVENT_ACTION_UP, client_motion_event.getActionMasked());
++    EXPECT_EQ(2, client_motion_event.getActionIndex());
++    EXPECT_EQ(2, client_motion_event.getPointerId(0));
++    EXPECT_EQ(3, client_motion_event.getPointerId(1));
++    EXPECT_EQ(4, client_motion_event.getPointerId(2));
++    EXPECT_EQ(3, client_motion_event.getPointerCount());
++}