1
=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h'
2
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h	2016-01-29 08:18:22 +0000
3
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/Input.h	2016-02-22 14:07:25 +0000
4
@@ -554,6 +554,7 @@
5
554
    }
554
    }
6
555
555
7
556
protected:
556
protected:
8
557
    float getAccumulatedAxisValue(int32_t axis, size_t pointerIndex) const;
9
557
    int32_t mAction;
558
    int32_t mAction;
10
558
    int32_t mFlags;
559
    int32_t mFlags;
11
559
    int32_t mEdgeFlags;
560
    int32_t mEdgeFlags;
12
560
561
13
=== modified file '3rd_party/android-input/android/frameworks/base/services/input/Input.cpp'
14
--- 3rd_party/android-input/android/frameworks/base/services/input/Input.cpp	2016-01-29 08:18:22 +0000
15
+++ 3rd_party/android-input/android/frameworks/base/services/input/Input.cpp	2016-02-22 14:07:25 +0000
16
@@ -359,12 +359,29 @@
17
359
    return &mSamplePointerCoords[getHistorySize() * getPointerCount() + pointerIndex];
359
    return &mSamplePointerCoords[getHistorySize() * getPointerCount() + pointerIndex];
18
360
}
360
}
19
361
361
20
362
float MotionEvent::getAccumulatedAxisValue(int32_t axis, size_t pointerIndex) const {
21
363
    float acc = 0;
22
364
    auto const pointerCount = getPointerCount();
23
365
    for (size_t i = 0, num_entries = getHistorySize() + 1; i != num_entries; ++i)
24
366
        acc += mSamplePointerCoords[i * pointerCount + pointerIndex].getAxisValue(axis);
25
367
    return acc;
26
368
}
27
369
28
362
float MotionEvent::getRawAxisValue(int32_t axis, size_t pointerIndex) const {
370
float MotionEvent::getRawAxisValue(int32_t axis, size_t pointerIndex) const {
30
363
    return getRawPointerCoords(pointerIndex)->getAxisValue(axis);
371
    switch (axis)
31
372
    {
32
373
    case AMOTION_EVENT_AXIS_RX:  // joystick rotation axis are abused as relative x and y
33
374
    case AMOTION_EVENT_AXIS_RY:
34
375
    case AMOTION_EVENT_AXIS_VSCROLL:
35
376
    case AMOTION_EVENT_AXIS_HSCROLL:
36
377
        return getAccumulatedAxisValue(axis, pointerIndex);
37
378
    default:
38
379
        return getRawPointerCoords(pointerIndex)->getAxisValue(axis);
39
380
    }
40
364
}
381
}
41
365
382
42
366
float MotionEvent::getAxisValue(int32_t axis, size_t pointerIndex) const {
383
float MotionEvent::getAxisValue(int32_t axis, size_t pointerIndex) const {
44
367
    float value = getRawPointerCoords(pointerIndex)->getAxisValue(axis);
384
    float value = getRawAxisValue(axis, pointerIndex);
45
368
    switch (axis) {
385
    switch (axis) {
46
369
    case AMOTION_EVENT_AXIS_X:
386
    case AMOTION_EVENT_AXIS_X:
47
370
        return value + mXOffset;
387
        return value + mXOffset;
48
371
388
49
=== modified file 'tests/unit-tests/input/android/CMakeLists.txt'
50
--- tests/unit-tests/input/android/CMakeLists.txt	2016-01-29 08:18:22 +0000
51
+++ tests/unit-tests/input/android/CMakeLists.txt	2016-02-22 14:07:25 +0000
52
@@ -3,6 +3,7 @@
53
3
  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_channel_factory.cpp
3
  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_channel_factory.cpp
54
4
  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_communication_package.cpp
4
  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_communication_package.cpp
55
5
  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_sender.cpp
5
  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_sender.cpp
56
6
  ${CMAKE_CURRENT_SOURCE_DIR}/test_input_consumer.cpp
57
6
)
7
)
58
7
8
59
8
set(
9
set(
60
9
10
61
=== added file 'tests/unit-tests/input/android/test_input_consumer.cpp'
62
--- tests/unit-tests/input/android/test_input_consumer.cpp	1970-01-01 00:00:00 +0000
63
+++ tests/unit-tests/input/android/test_input_consumer.cpp	2016-02-22 14:07:25 +0000
64
@@ -0,0 +1,252 @@
65
1
/*
66
2
 * Copyright © 2016 Canonical Ltd.
67
3
 *
68
4
 * This program is free software: you can redistribute it and/or modify it
69
5
 * under the terms of the GNU General Public License version 3,
70
6
 * as published by the Free Software Foundation.
71
7
 *
72
8
 * This program is distributed in the hope that it will be useful,
73
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
74
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
75
11
 * GNU General Public License for more details.
76
12
 *
77
13
 * You should have received a copy of the GNU General Public License
78
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
79
15
 *
80
16
 * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
81
17
 */
82
18
83
19
#include "androidfw/Input.h"
84
20
#include "androidfw/InputTransport.h"
85
21
#include "src/server/input/android/android_input_channel.h"
86
22
#include "mir/input/android/event_conversion_helpers.h"
87
23
#include "mir/input/android/android_input_lexicon.h"
88
24
#include "mir/geometry/displacement.h"
89
25
#include "mir/geometry/point.h"
90
26
91
27
#include <gtest/gtest.h>
92
28
#include <chrono>
93
29
#include <vector>
94
30
#include <cstring>
95
31
96
32
using namespace std::literals::chrono_literals;
97
33
namespace mia = mir::input::android;
98
34
namespace geom = mir::geometry;
99
35
100
36
namespace
101
37
{
102
38
struct EventFactory : android::InputEventFactoryInterface
103
39
{
104
40
    android::KeyEvent key;
105
41
    android::MotionEvent motion;
106
42
    android::KeyEvent* createKeyEvent()
107
43
    {
108
44
        return &key;
109
45
    }
110
46
    android::MotionEvent* createMotionEvent()
111
47
    {
112
48
        return &motion;
113
49
    }
114
50
};
115
51
}
116
52
117
53
struct InputConsumerTest : ::testing::Test
118
54
{
119
55
    MOCK_METHOD3(pointer_movement,void(geom::Point pos, geom::Displacement movement, geom::Displacement scroll));
120
56
    uint32_t seq{0};
121
57
    mir::cookie::Blob default_cookie;
122
58
    EventFactory events;
123
59
    std::chrono::milliseconds current_frame_time = 0ms;
124
60
    mia::AndroidInputChannel channel;
125
61
    geom::Displacement no_move{0,0};
126
62
    geom::Displacement no_scroll{0,0};
127
63
    geom::Point origin{0,0};
128
64
    droidinput::sp<droidinput::InputChannel> client_channel =
129
65
        new droidinput::InputChannel("test_client", channel.client_fd());
130
66
    droidinput::sp<droidinput::InputChannel> server_channel =
131
67
        new droidinput::InputChannel("test_server", channel.server_fd());
132
68
133
69
    droidinput::InputPublisher publisher{server_channel};
134
70
    droidinput::InputConsumer consumer{client_channel};
135
71
136
72
    InputConsumerTest()
137
73
    {
138
74
        std::memset(&default_cookie, 0, sizeof default_cookie);
139
75
    }
140
76
141
77
    const MirInputDeviceId touchscreen_device = 2;
142
78
    const MirInputDeviceId mouse_device = 3;
143
79
    struct TouchEvent
144
80
    {
145
81
        int action; // only one action per event - android InputTransport restriction
146
82
        std::vector<geom::Point> positions;
147
83
        std::chrono::nanoseconds tp;
148
84
    };
149
85
    void send_touch_event(TouchEvent const& event)
150
86
    {
151
87
        std::vector<droidinput::PointerCoords> coords(event.positions.size());
152
88
        std::vector<droidinput::PointerProperties> properties(event.positions.size());
153
89
        std::memset(coords.data(), 0, sizeof coords[0] * coords.size());
154
90
        std::memset(properties.data(), 0, sizeof properties[0] * properties.size());
155
91
        auto const x_offset = 0.0f;
156
92
        auto const y_offset = 0.0f;
157
93
        auto const x_precision = 0;
158
94
        auto const y_precision = 0;
159
95
        auto const flags = 0;
160
96
        auto const edge_flags = 0;
161
97
        auto const button_state = 0;
162
98
        int contacts_in_event = 0;
163
99
        for (auto const& contact : event.positions)
164
100
        {
165
101
            coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_X, contact.x.as_float());
166
102
            coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_Y, contact.y.as_float());
167
103
            coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 5);
168
104
            coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 5);
169
105
            coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 5);
170
106
            coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 0.7);
171
107
            properties[contacts_in_event].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
172
108
            properties[contacts_in_event].id = contacts_in_event;
173
109
        }
174
110
175
111
        publisher.publishMotionEvent(++seq, touchscreen_device, AINPUT_SOURCE_TOUCHSCREEN, event.action, flags,
176
112
                                     edge_flags, 0, button_state, x_offset, y_offset, x_precision, y_precision,
177
113
                                     default_cookie, event.tp, event.tp, contacts_in_event, properties.data(),
178
114
                                     coords.data());
179
115
    }
180
116
181
117
    struct PointerEvent
182
118
    {
183
119
        MirPointerAction action;
184
120
        MirPointerButtons buttons;
185
121
        geom::Point position;
186
122
        geom::Displacement movement;
187
123
        geom::Displacement scroll;
188
124
        std::chrono::nanoseconds tp;
189
125
    };
190
126
    void send_pointer_event(PointerEvent const& event)
191
127
    {
192
128
        droidinput::PointerCoords pointer_coord;
193
129
        droidinput::PointerProperties pointer_properties;
194
130
        std::memset(&pointer_coord, 0, sizeof(pointer_coord));
195
131
        std::memset(&pointer_properties, 0, sizeof(pointer_properties));
196
132
197
133
        pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_X, event.position.x.as_float());
198
134
        pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_Y, event.position.y.as_float());
199
135
        pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, event.scroll.dx.as_float());
200
136
        pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, event.scroll.dy.as_float());
201
137
        pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_RX, event.movement.dx.as_float());
202
138
        pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_RY, event.movement.dy.as_float());
203
139
        pointer_properties.toolType = AMOTION_EVENT_TOOL_TYPE_MOUSE;
204
140
        pointer_properties.id = 0;
205
141
206
142
        auto const x_offset = 0.0f;
207
143
        auto const y_offset = 0.0f;
208
144
        auto const x_precision = 0;
209
145
        auto const y_precision = 0;
210
146
        auto const flags = 0;
211
147
        auto const buttons = 0;
212
148
        auto const modifiers = 0;
213
149
        auto const edge_flags = 0;
214
150
        publisher.publishMotionEvent(++seq, mouse_device, AINPUT_SOURCE_MOUSE,
215
151
                                     mia::android_pointer_action_from_mir(event.action, event.buttons), flags,
216
152
                                     edge_flags, modifiers, buttons, x_offset, y_offset, x_precision, y_precision,
217
153
                                     default_cookie, event.tp, event.tp, 1, &pointer_properties, &pointer_coord);
218
154
    }
219
155
220
156
    void handle_event(droidinput::InputEvent* event)
221
157
    {
222
158
        if (event->getType() == AINPUT_EVENT_TYPE_KEY)
223
159
        {
224
160
        }
225
161
        else
226
162
        {
227
163
228
164
            if (mia::android_source_id_is_pointer_device(event->getSource()))
229
165
            {
230
166
                auto mev = static_cast<const droidinput::MotionEvent*>(event);
231
167
                pointer_movement(
232
168
                    {mev->getX(0), mev->getY(0)},
233
169
                    {mev->getRawAxisValue(AMOTION_EVENT_AXIS_RX, 0),
234
170
                     mev->getRawAxisValue(AMOTION_EVENT_AXIS_RY, 0)},
235
171
                    {mev->getRawAxisValue(AMOTION_EVENT_AXIS_HSCROLL, 0),
236
172
                     mev->getRawAxisValue(AMOTION_EVENT_AXIS_VSCROLL, 0)}
237
173
                     );
238
174
            }
239
175
        }
240
176
    }
241
177
    void receive_events()
242
178
    {
243
179
        const auto fake_update_rate = 1ms;
244
180
245
181
        android::InputEvent *received_event = nullptr;
246
182
        uint32_t seq_id;
247
183
        do
248
184
        {
249
185
            auto result = consumer.consume(&events, true, current_frame_time, &seq_id, &received_event);
250
186
251
187
            if (result == droidinput::OK)
252
188
                handle_event(received_event);
253
189
254
190
            if (consumer.hasPendingBatch())
255
191
                current_frame_time += fake_update_rate;
256
192
        } while(consumer.hasPendingBatch() || consumer.hasDeferredEvent());
257
193
    }
258
194
259
195
    void advance_frame_time_to(std::chrono::milliseconds time)
260
196
    {
261
197
        current_frame_time = time;
262
198
    }
263
199
264
200
};
265
201
266
202
TEST_F(InputConsumerTest, emits_single_move_event_on_old_pointer_messages)
267
203
{
268
204
    EXPECT_CALL(*this, pointer_movement(geom::Point{4,11}, geom::Displacement{2,1}, no_scroll));
269
205
270
206
    send_pointer_event({mir_pointer_action_motion, 0, {2.0, 10.0}, {0.0, 0.0}, no_scroll, 0ns});
271
207
    send_pointer_event({mir_pointer_action_motion, 0, {3.0, 11.0}, {1.0, 1.0}, no_scroll, 1ms});
272
208
    send_pointer_event({mir_pointer_action_motion, 0, {4.0, 11.0}, {1.0, 0.0}, no_scroll, 2ms});
273
209
274
210
    advance_frame_time_to(16ms);
275
211
    receive_events();
276
212
}
277
213
278
214
TEST_F(InputConsumerTest, emits_move_events_on_recent_messages)
279
215
{
280
216
    EXPECT_CALL(*this, pointer_movement(geom::Point{10, 5}, geom::Displacement{0, 0}, no_scroll));
281
217
    EXPECT_CALL(*this, pointer_movement(geom::Point{15, 8}, geom::Displacement{5, 3}, no_scroll));
282
218
    EXPECT_CALL(*this, pointer_movement(geom::Point{12,10}, geom::Displacement{-3, 2}, no_scroll));
283
219
284
220
    send_pointer_event({mir_pointer_action_motion, 0, {10.0, 5.0}, {0.0, 0.0}, no_scroll, 0ns});
285
221
    send_pointer_event({mir_pointer_action_motion, 0, {15.0, 8.0}, {5.0, 3.0}, no_scroll, 1ms});
286
222
    send_pointer_event({mir_pointer_action_motion, 0, {12.0, 10.0}, {-3.0,2.0}, no_scroll, 2ms});
287
223
288
224
    advance_frame_time_to(2ms);
289
225
    receive_events();
290
226
}
291
227
292
228
TEST_F(InputConsumerTest, emits_scroll_events_on_each_recent_scroll_messages)
293
229
{
294
230
    EXPECT_CALL(*this, pointer_movement(origin, no_move, geom::Displacement{3, 0}));
295
231
    EXPECT_CALL(*this, pointer_movement(origin, no_move, geom::Displacement{0, 5}));
296
232
    EXPECT_CALL(*this, pointer_movement(origin, no_move, geom::Displacement{2, 5}));
297
233
298
234
    send_pointer_event({mir_pointer_action_motion, 0, origin, no_move, {3.0, 0.0}, 0ns});
299
235
    send_pointer_event({mir_pointer_action_motion, 0, origin, no_move, {0.0, 5.0}, 1ms});
300
236
    send_pointer_event({mir_pointer_action_motion, 0, origin, no_move, {2.0, 5.0}, 2ms});
301
237
302
238
    advance_frame_time_to(2ms);
303
239
    receive_events();
304
240
}
305
241
306
242
TEST_F(InputConsumerTest, emits_accumulated_scroll_event_on_old_messages)
307
243
{
308
244
    EXPECT_CALL(*this, pointer_movement(origin, no_move, geom::Displacement{5, 10}));
309
245
310
246
    send_pointer_event({mir_pointer_action_motion, 0, origin, no_move, {3.0, 0.0}, 0ns});
311
247
    send_pointer_event({mir_pointer_action_motion, 0, origin, no_move, {0.0, 5.0}, 1ms});
312
248
    send_pointer_event({mir_pointer_action_motion, 0, origin, no_move, {2.0, 5.0}, 2ms});
313
249
314
250
    advance_frame_time_to(16ms);
315
251
    receive_events();
316
252
}
Reviewer	Review Type	Date Requested	Status
Cemil Azizoglu (community)			Approve on 2016-02-23
Alan Griffiths			Approve on 2016-02-23
Daniel van Vugt		2016-02-19	Approve on 2016-02-23
PS Jenkins bot (community)	continuous-integration		Approve on 2016-02-22
Mir CI Bot	continuous-integration		Approve on 2016-02-22
Review via email: mp+286697@code.launchpad.net