1
=== modified file 'examples/fingerpaint.c'
2
--- examples/fingerpaint.c	2017-01-12 03:18:54 +0000
3
+++ examples/fingerpaint.c	2017-01-16 08:35:54 +0000
4
@@ -16,8 +16,6 @@
5
16
 * Author: Daniel van Vugt <daniel.van.vugt@canonical.com>
16
 * Author: Daniel van Vugt <daniel.van.vugt@canonical.com>
6
17
 */
17
 */
7
18
18
8
19
#define _POSIX_C_SOURCE 200112L  // for setenv() from stdlib.h
9
20
10
21
#include "mir_toolkit/mir_client_library.h"
19
#include "mir_toolkit/mir_client_library.h"
11
22
#include "mir_toolkit/events/input/input_event.h"
20
#include "mir_toolkit/events/input/input_event.h"
12
23
21
13
@@ -415,10 +413,6 @@
14
415
        }
413
        }
15
416
    }
414
    }
16
417
415
17
418
    // We do our own resampling now. We can keep up with raw input...
18
419
    // TODO: Replace setenv with a proper Mir function (LP: #1439590)
19
420
    setenv("MIR_CLIENT_INPUT_RATE", "0", 0);
20
421
21
422
    conn = mir_connect_sync(mir_socket, argv[0]);
416
    conn = mir_connect_sync(mir_socket, argv[0]);
22
423
    if (!mir_connection_is_valid(conn))
417
    if (!mir_connection_is_valid(conn))
23
424
    {
418
    {
24
425
419
25
=== modified file 'examples/target.c'
26
--- examples/target.c	2017-01-12 03:18:54 +0000
27
+++ examples/target.c	2017-01-16 08:35:54 +0000
28
@@ -16,7 +16,6 @@
29
16
 * Author: Daniel van Vugt <daniel.van.vugt@canonical.com>
16
 * Author: Daniel van Vugt <daniel.van.vugt@canonical.com>
30
17
 */
17
 */
31
18
18
32
19
#define _POSIX_C_SOURCE 200112L  // for setenv() from stdlib.h
33
20
#include "eglapp.h"
19
#include "eglapp.h"
34
21
#include <assert.h>
20
#include <assert.h>
35
22
#include <stdio.h>
21
#include <stdio.h>
36
@@ -265,11 +264,6 @@
37
265
    sigaddset(&sigs, SIGHUP);
264
    sigaddset(&sigs, SIGHUP);
38
266
    pthread_sigmask(SIG_BLOCK, &sigs, NULL);
265
    pthread_sigmask(SIG_BLOCK, &sigs, NULL);
39
267
266
40
268
    // Disable Mir's input resampling. We do our own here, in a way that
41
269
    // has even lower latency than Mir's default algorithm.
42
270
    // TODO: Make a proper client API function for this:
43
271
    setenv("MIR_CLIENT_INPUT_RATE", "0", 0);
44
272
45
273
    static unsigned int width = 0, height = 0;
267
    static unsigned int width = 0, height = 0;
46
274
    if (!mir_eglapp_init(argc, argv, &width, &height, NULL))
268
    if (!mir_eglapp_init(argc, argv, &width, &height, NULL))
47
275
        return 1;
269
        return 1;
48
276
270
49
=== modified file 'src/client/input/android/android_input_receiver.cpp'
50
--- src/client/input/android/android_input_receiver.cpp	2016-10-31 02:37:31 +0000
51
+++ src/client/input/android/android_input_receiver.cpp	2017-01-16 08:35:54 +0000
52
@@ -53,54 +53,29 @@
53
53
mircva::InputReceiver::InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel,
53
mircva::InputReceiver::InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel,
54
54
                                     std::shared_ptr<mircv::XKBMapper> const& keymapper,
54
                                     std::shared_ptr<mircv::XKBMapper> const& keymapper,
55
55
                                     std::function<void(MirEvent*)> const& event_handling_callback,
55
                                     std::function<void(MirEvent*)> const& event_handling_callback,
61
56
                                     std::shared_ptr<mircv::InputReceiverReport> const& report,
56
                                     std::shared_ptr<mircv::InputReceiverReport> const& report)
62
57
                                     AndroidClock clock)
57
  : wake_fd{valid_fd_or_system_error(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK),
58
58
  : timer_fd{valid_fd_or_system_error(timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC),
59
59
        "Failed to create IO timer")},
60
60
    wake_fd{valid_fd_or_system_error(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK | EFD_SEMAPHORE),
63
61
        "Failed to create IO wakeup notifier")},
58
        "Failed to create IO wakeup notifier")},
64
62
    input_channel(input_channel),
59
    input_channel(input_channel),
65
63
    handler{event_handling_callback},
60
    handler{event_handling_callback},
66
64
    xkb_mapper(keymapper),
61
    xkb_mapper(keymapper),
67
65
    report(report),
62
    report(report),
70
66
    input_consumer(std::make_shared<droidinput::InputConsumer>(input_channel)),
63
    input_consumer(std::make_shared<droidinput::InputConsumer>(input_channel))
69
67
    android_clock(clock)
71
68
{
64
{
93
69
    /*
65
    dispatcher.add_watch(wake_fd,
94
70
     * 59Hz by default. This ensures the input rate never gets ahead of the
66
                         [this]() { woke(); });
74
71
     * typical display rate, which would be seen as visible lag.
75
72
     */
76
73
    event_rate_hz = 59;
77
74
    auto env = getenv("MIR_CLIENT_INPUT_RATE");
78
75
    if (env != NULL)
79
76
        event_rate_hz = atoi(env);
80
77
81
78
    dispatcher.add_watch(timer_fd, [this]()
82
79
    {
83
80
        consume_wake_notification(timer_fd);
84
81
        process_and_maybe_send_event();
85
82
    });
86
83
87
84
    dispatcher.add_watch(wake_fd, [this]()
88
85
    {
89
86
        consume_wake_notification(wake_fd);
90
87
        process_and_maybe_send_event();
91
88
    });
92
89
95
90
    dispatcher.add_watch(mir::Fd{mir::IntOwnedFd{input_channel->getFd()}},
67
    dispatcher.add_watch(mir::Fd{mir::IntOwnedFd{input_channel->getFd()}},
97
91
                         [this]() { process_and_maybe_send_event(); });
68
                         [this]() { woke(); });
98
92
}
69
}
99
93
70
100
94
mircva::InputReceiver::InputReceiver(int fd,
71
mircva::InputReceiver::InputReceiver(int fd,
101
95
                                     std::shared_ptr<mircv::XKBMapper> const& keymapper,
72
                                     std::shared_ptr<mircv::XKBMapper> const& keymapper,
102
96
                                     std::function<void(MirEvent*)> const& event_handling_callback,
73
                                     std::function<void(MirEvent*)> const& event_handling_callback,
105
97
                                     std::shared_ptr<mircv::InputReceiverReport> const& report,
74
                                     std::shared_ptr<mircv::InputReceiverReport> const& report)
104
98
                                     AndroidClock clock)
106
99
    : InputReceiver(new droidinput::InputChannel(droidinput::String8(""), fd),
75
    : InputReceiver(new droidinput::InputChannel(droidinput::String8(""), fd),
107
100
                    keymapper,
76
                    keymapper,
108
101
                    event_handling_callback,
77
                    event_handling_callback,
111
102
                    report,
78
                    report)
110
103
                    clock)
112
104
{
79
{
113
105
}
80
}
114
106
81
115
@@ -138,36 +113,28 @@
116
138
113
117
139
}
114
}
118
140
115
120
141
void mircva::InputReceiver::process_and_maybe_send_event()
116
void mircva::InputReceiver::woke()
121
142
{
117
{
122
118
    uint64_t dummy;
123
119
124
120
    /*
125
121
     * We never care about the cause of the wakeup. Either real input or a
126
122
     * wake(). Either way the only requirement is that we woke() after each
127
123
     * wake() or real input channel event.
128
124
     */
129
125
    if (read(wake_fd, &dummy, sizeof(dummy)) != sizeof(dummy) &&
130
126
        errno != EAGAIN &&
131
127
        errno != EINTR)
132
128
    {
133
129
        BOOST_THROW_EXCEPTION((std::system_error{errno,
134
130
                                                 std::system_category(),
135
131
                                                 "Failed to consume notification"}));
136
132
    }
137
133
138
143
    droidinput::InputEvent *android_event;
134
    droidinput::InputEvent *android_event;
139
144
    uint32_t event_sequence_id;
135
    uint32_t event_sequence_id;
140
145
136
166
146
    /*
137
    auto const frame_time = std::chrono::nanoseconds(-1);
142
147
     * Enable "Project Butter" input resampling in InputConsumer::consume():
143
148
     *   consumeBatches = true, so as to ensure the "cooked" event rate that
144
149
     *      clients experience is at least the minimum of event_rate_hz
145
150
     *      and the raw device event rate.
146
151
     *   frame_time = A regular interval. This provides a virtual frame
147
152
     *      interval during which InputConsumer will collect raw events,
148
153
     *      resample them and emit a "cooked" event back to us at roughly every
149
154
     *      60th of a second. "cooked" events are both smoothed and
150
155
     *      extrapolated/predicted into the future (for tool=finger) giving the
151
156
     *      appearance of lower latency. Getting a real frame time from the
152
157
     *      graphics logic (which is messy) does not appear to be necessary to
153
158
     *      gain significant benefit.
154
159
     */
155
160
156
161
    auto frame_time = std::chrono::nanoseconds(-1);
157
162
158
163
    if (event_rate_hz > 0)
159
164
    {
160
165
        auto one_frame = std::chrono::nanoseconds(1000000000ULL / event_rate_hz);
161
166
        std::chrono::nanoseconds const
162
167
            now = android_clock(SYSTEM_TIME_MONOTONIC);
163
168
        frame_time = (now / one_frame) * one_frame;
164
169
    }
165
170
167
171
    auto result = input_consumer->consume(&event_factory,
138
    auto result = input_consumer->consume(&event_factory,
168
172
                                          true,
139
                                          true,
169
173
                                          frame_time,
140
                                          frame_time,
170
@@ -197,45 +164,6 @@
171
197
        // So, we ensure we'll appear dispatchable by pushing an event to the wakeup pipe.
164
        // So, we ensure we'll appear dispatchable by pushing an event to the wakeup pipe.
172
198
        wake();
165
        wake();
173
199
    }
166
    }
174
200
    else if (input_consumer->hasPendingBatch() && event_rate_hz > 0)
175
201
    {
176
202
        using namespace std::chrono;
177
203
        // If we batch according to a fixed event rate - we wait until the next "frame" occurs.
178
204
        auto one_frame = nanoseconds(1000000000ULL / event_rate_hz);
179
205
        auto now = android_clock(SYSTEM_TIME_MONOTONIC);
180
206
        auto next_frame = frame_time + one_frame;
181
207
182
208
        if (next_frame <= now)
183
209
        {
184
210
            wake();
185
211
        }
186
212
        else
187
213
        {
188
214
            auto full_sec = duration_cast<duration<long>>(next_frame);
189
215
            auto nano_sec = duration_cast<duration<long,std::nano>>(next_frame - full_sec);
190
216
            struct itimerspec const frame_timeout = {
191
217
                { 0, 0 },
192
218
                { full_sec.count(), nano_sec.count()}
193
219
            };
194
220
            if (timerfd_settime(timer_fd, TFD_TIMER_ABSTIME, &frame_timeout, NULL) < 0)
195
221
            {
196
222
                BOOST_THROW_EXCEPTION((std::system_error{errno,
197
223
                                       std::system_category(),
198
224
                                       "Failed to arm timer"}));
199
225
            }
200
226
        }
201
227
    }
202
228
}
203
229
204
230
void mircva::InputReceiver::consume_wake_notification(mir::Fd const& fd)
205
231
{
206
232
    uint64_t dummy;
207
233
    if (read(fd, &dummy, sizeof(dummy)) != sizeof(dummy))
208
234
    {
209
235
        BOOST_THROW_EXCEPTION((std::system_error{errno,
210
236
                                                 std::system_category(),
211
237
                                                 "Failed to consume notification"}));
212
238
    }
213
239
}
167
}
214
240
168
215
241
void mircva::InputReceiver::wake()
169
void mircva::InputReceiver::wake()
216
242
170
217
=== modified file 'src/client/input/android/android_input_receiver.h'
218
--- src/client/input/android/android_input_receiver.h	2016-01-29 08:18:22 +0000
219
+++ src/client/input/android/android_input_receiver.h	2017-01-16 08:35:54 +0000
220
@@ -56,18 +56,14 @@
221
56
class InputReceiver : public dispatch::Dispatchable
56
class InputReceiver : public dispatch::Dispatchable
222
57
{
57
{
223
58
public:
58
public:
224
59
    typedef std::function<std::chrono::nanoseconds(int)> AndroidClock;
225
60
226
61
    InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel,
59
    InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel,
227
62
                  std::shared_ptr<XKBMapper> const& keymapper,
60
                  std::shared_ptr<XKBMapper> const& keymapper,
228
63
                  std::function<void(MirEvent*)> const& event_handling_callback,
61
                  std::function<void(MirEvent*)> const& event_handling_callback,
231
64
                  std::shared_ptr<InputReceiverReport> const& report,
62
                  std::shared_ptr<InputReceiverReport> const& report);
230
65
                  AndroidClock clock = systemTime);
232
66
    InputReceiver(int fd,
63
    InputReceiver(int fd,
233
67
                  std::shared_ptr<XKBMapper> const& keymapper,
64
                  std::shared_ptr<XKBMapper> const& keymapper,
234
68
                  std::function<void(MirEvent*)> const& event_handling_callback,
65
                  std::function<void(MirEvent*)> const& event_handling_callback,
237
69
                  std::shared_ptr<InputReceiverReport> const& report,
66
                  std::shared_ptr<InputReceiverReport> const& report);
236
70
                  AndroidClock clock = systemTime);
238
71
67
239
72
    virtual ~InputReceiver();
68
    virtual ~InputReceiver();
240
73
69
241
@@ -81,7 +77,6 @@
242
81
77
243
82
private:
78
private:
244
83
    dispatch::MultiplexingDispatchable dispatcher;
79
    dispatch::MultiplexingDispatchable dispatcher;
245
84
    Fd const timer_fd;
246
85
    Fd const wake_fd;
80
    Fd const wake_fd;
247
86
81
248
87
    droidinput::sp<droidinput::InputChannel> input_channel;
82
    droidinput::sp<droidinput::InputChannel> input_channel;
249
@@ -92,11 +87,7 @@
250
92
    std::shared_ptr<droidinput::InputConsumer> input_consumer;
87
    std::shared_ptr<droidinput::InputConsumer> input_consumer;
251
93
    droidinput::PreallocatedInputEventFactory event_factory;
88
    droidinput::PreallocatedInputEventFactory event_factory;
252
94
89
258
95
    AndroidClock const android_clock;
90
    void woke();
254
96
    int event_rate_hz;
255
97
256
98
    void process_and_maybe_send_event();
257
99
    static void consume_wake_notification(mir::Fd const& fd);
259
100
    void wake();
91
    void wake();
260
101
};
92
};
261
102
93
262
103
94
263
=== modified file 'tests/acceptance-tests/test_client_input.cpp'
264
--- tests/acceptance-tests/test_client_input.cpp	2017-01-16 04:43:36 +0000
265
+++ tests/acceptance-tests/test_client_input.cpp	2017-01-16 08:35:54 +0000
266
@@ -330,8 +330,6 @@
267
330
330
268
331
TEST_F(TestClientInput, clients_receive_relative_pointer_events)
331
TEST_F(TestClientInput, clients_receive_relative_pointer_events)
269
332
{
332
{
270
333
    mtf::TemporaryEnvironmentValue disable_batching("MIR_CLIENT_INPUT_RATE", "0");
271
334
    
272
335
    positions[first] = geom::Rectangle{{0,0}, {surface_width, surface_height}};
333
    positions[first] = geom::Rectangle{{0,0}, {surface_width, surface_height}};
273
336
    Client first_client(new_connection(), first);
334
    Client first_client(new_connection(), first);
274
337
335
275
@@ -648,68 +646,6 @@
276
648
    first_client.all_events_received.wait_for(2s);
646
    first_client.all_events_received.wait_for(2s);
277
649
}
647
}
278
650
648
279
651
TEST_F(TestClientInput, receives_one_touch_event_per_frame)
280
652
{
281
653
    positions[first] = screen_geometry;
282
654
    Client first_client(new_connection(), first);
283
655
284
656
    int const frame_rate = 60;
285
657
    int const input_rate = 500;
286
658
    int const nframes = 100;
287
659
    int const nframes_error = 80;
288
660
    int const inputs_per_frame = input_rate / frame_rate;
289
661
    int const ninputs = nframes * inputs_per_frame;
290
662
    auto const frame_time = 1000ms / frame_rate;
291
663
    auto const input_interval = std::chrono::duration<double>(1s) / input_rate;
292
664
293
665
    int received_input_events = 0;
294
666
295
667
    EXPECT_CALL(first_client, handle_input(_))
296
668
        .Times(Between(nframes-nframes_error, nframes+nframes_error))
297
669
        .WillRepeatedly(InvokeWithoutArgs(
298
670
            [&]()
299
671
            {
300
672
                ++received_input_events;
301
673
                if (received_input_events >= nframes-nframes_error)
302
674
                    first_client.all_events_received.raise();
303
675
            }));
304
676
305
677
    fake_touch_screen->emit_event(mis::a_touch_event()
306
678
                                  .at_position({0,0}));
307
679
308
680
    ASSERT_THAT(input_rate, Ge(2 * frame_rate));
309
681
    ASSERT_THAT(ninputs, Gt(2 * nframes));
310
682
311
683
    fake_touch_screen->emit_touch_sequence(
312
684
        [this](int i)
313
685
        {
314
686
            auto const x = i;
315
687
            auto const y = 2*i;
316
688
            return mis::a_touch_event()
317
689
                .with_action(mis::TouchParameters::Action::Move)
318
690
                .at_position({x,y});
319
691
        },
320
692
        ninputs,
321
693
        input_interval
322
694
        );
323
695
324
696
    // The main thing we're testing for is that too many events don't arrive
325
697
    // so we wait a little to check the cooked event stream has stopped:
326
698
    std::this_thread::sleep_for(200 * frame_time);
327
699
328
700
    // Wait for the expected minimum number of events (should be quick but
329
701
    // some CI runs are actually incredibly slow to finish)
330
702
    ASSERT_TRUE(first_client.all_events_received.wait_for(120s));
331
703
332
704
    // Remove reference to local received_input_events
333
705
    Mock::VerifyAndClearExpectations(&first_client);
334
706
335
707
    float const client_input_events_per_frame =
336
708
        (float)received_input_events / nframes;
337
709
    EXPECT_THAT(client_input_events_per_frame, Gt(0.0f));
338
710
    EXPECT_THAT(client_input_events_per_frame, Lt(2.0f));
339
711
}
340
712
341
713
TEST_F(TestClientInput, send_mir_input_events_through_surface)
649
TEST_F(TestClientInput, send_mir_input_events_through_surface)
342
714
{
650
{
343
715
    Client first_client(new_connection(), first);
651
    Client first_client(new_connection(), first);
344
716
652
345
=== modified file 'tests/acceptance-tests/test_confined_pointer.cpp'
346
--- tests/acceptance-tests/test_confined_pointer.cpp	2017-01-12 03:18:54 +0000
347
+++ tests/acceptance-tests/test_confined_pointer.cpp	2017-01-16 08:35:54 +0000
348
@@ -206,7 +206,6 @@
349
206
    std::string first{"first"};
206
    std::string first{"first"};
350
207
    std::string second{"second"};
207
    std::string second{"second"};
351
208
    mtf::ClientPositions positions;
208
    mtf::ClientPositions positions;
352
209
    mtf::TemporaryEnvironmentValue disable_batching{"MIR_CLIENT_INPUT_RATE", "0"};
353
210
};
209
};
354
211
210
355
212
TEST_F(PointerConfinement, test_we_hit_pointer_confined_boundary)
211
TEST_F(PointerConfinement, test_we_hit_pointer_confined_boundary)
356
213
212
357
=== modified file 'tests/unit-tests/client/input/test_android_input_receiver.cpp'
358
--- tests/unit-tests/client/input/test_android_input_receiver.cpp	2016-11-11 06:59:42 +0000
359
+++ tests/unit-tests/client/input/test_android_input_receiver.cpp	2017-01-16 08:35:54 +0000
360
@@ -36,6 +36,7 @@
361
36
#include <memory>
36
#include <memory>
362
37
#include <system_error>
37
#include <system_error>
363
38
#include <boost/throw_exception.hpp>
38
#include <boost/throw_exception.hpp>
364
39
#include <atomic>
365
39
40
366
40
namespace mircv = mir::input::receiver;
41
namespace mircv = mir::input::receiver;
367
41
namespace mircva = mircv::android;
42
namespace mircva = mircv::android;
368
@@ -193,7 +194,7 @@
369
193
    EXPECT_TRUE(producer.must_receive_handled_signal());
194
    EXPECT_TRUE(producer.must_receive_handled_signal());
370
194
}
195
}
371
195
196
373
196
TEST_F(AndroidInputReceiverSetup, receiver_consumes_batched_motion_events)
197
TEST_F(AndroidInputReceiverSetup, receiver_consumes_all_motion_events)
374
197
{
198
{
375
198
    mircva::InputReceiver receiver{channel.client_fd(),
199
    mircva::InputReceiver receiver{channel.client_fd(),
376
199
                                   std::make_shared<mircv::XKBMapper>(),
200
                                   std::make_shared<mircv::XKBMapper>(),
377
@@ -203,14 +204,18 @@
378
203
    TestingInputProducer producer(channel.server_fd());
204
    TestingInputProducer producer(channel.server_fd());
379
204
205
380
205
    // Produce 3 motion events before client handles any.
206
    // Produce 3 motion events before client handles any.
384
206
    producer.produce_a_pointer_event(0, 0, std::chrono::nanoseconds(0));
207
    int const nevents = 3;
385
207
    producer.produce_a_pointer_event(0, 0, std::chrono::nanoseconds(0));
208
    for (int i = 0; i < nevents; ++i)
386
208
    producer.produce_a_pointer_event(0, 0, std::chrono::nanoseconds(0));
209
        producer.produce_a_pointer_event(0, 0, std::chrono::nanoseconds(0));
387
209
210
388
210
    flush_channels();
211
    flush_channels();
389
211
212
392
212
    EXPECT_TRUE(mt::fd_becomes_readable(receiver.watch_fd(), next_event_timeout));
213
    for (int j = 0; j < nevents; ++j)
393
213
    receiver.dispatch(md::FdEvent::readable);
214
    {
394
215
        EXPECT_TRUE(mt::fd_becomes_readable(receiver.watch_fd(),
395
216
                                            next_event_timeout));
396
217
        receiver.dispatch(md::FdEvent::readable);
397
218
    }
398
214
219
399
215
    // Now there should be no events
220
    // Now there should be no events
400
216
    EXPECT_FALSE(mt::fd_is_readable(receiver.watch_fd()));
221
    EXPECT_FALSE(mt::fd_is_readable(receiver.watch_fd()));
401
@@ -218,50 +223,33 @@
402
218
223
403
219
TEST_F(AndroidInputReceiverSetup, slow_raw_input_doesnt_cause_frameskipping)
224
TEST_F(AndroidInputReceiverSetup, slow_raw_input_doesnt_cause_frameskipping)
404
220
{  // Regression test for LP: #1372300
225
{  // Regression test for LP: #1372300
405
221
    using namespace testing;
406
222
    using namespace std::chrono;
226
    using namespace std::chrono;
407
223
    using namespace std::literals::chrono_literals;
227
    using namespace std::literals::chrono_literals;
408
224
228
413
225
    auto t = 0ns;
229
    std::atomic_int handler_called{0};
410
226
411
227
    std::unique_ptr<MirEvent> ev;
412
228
    bool handler_called{false};
414
229
230
415
230
    mircva::InputReceiver receiver{channel.client_fd(),
231
    mircva::InputReceiver receiver{channel.client_fd(),
416
231
                                   std::make_shared<mircv::XKBMapper>(),
232
                                   std::make_shared<mircv::XKBMapper>(),
418
232
                                   [&ev, &handler_called](MirEvent* event)
233
                                   [&handler_called](MirEvent*)
419
233
                                   {
234
                                   {
422
234
                                       ev.reset(new MirEvent(*event));
235
                                       ++handler_called;
421
235
                                       handler_called = true;
423
236
                                   },
236
                                   },
429
237
                                   std::make_shared<mircv::NullInputReceiverReport>(),
237
                                   std::make_shared<mircv::NullInputReceiverReport>()};
425
238
                                   [&t](int)
426
239
                                   {
427
240
                                       return t;
428
241
                                   }};
430
242
    TestingInputProducer producer(channel.server_fd());
238
    TestingInputProducer producer(channel.server_fd());
431
243
239
432
244
    nanoseconds const one_frame = duration_cast<nanoseconds>(1s) / 59;
240
    nanoseconds const one_frame = duration_cast<nanoseconds>(1s) / 59;
433
245
241
436
246
    producer.produce_a_pointer_event(123, 456, t);
242
    producer.produce_a_pointer_event(123, 456, 0ns);
437
247
    producer.produce_a_key_event();
243
    producer.produce_a_pointer_event(234, 567, one_frame);
438
248
    flush_channels();
244
    flush_channels();
439
249
245
440
250
    // Key events don't get resampled. Will be reported first.
441
251
    EXPECT_TRUE(mt::fd_becomes_readable(receiver.watch_fd(), next_event_timeout));
246
    EXPECT_TRUE(mt::fd_becomes_readable(receiver.watch_fd(), next_event_timeout));
442
252
    receiver.dispatch(md::FdEvent::readable);
247
    receiver.dispatch(md::FdEvent::readable);
445
253
    EXPECT_TRUE(handler_called);
248
    EXPECT_EQ(1, handler_called);
444
254
    ASSERT_EQ(mir_input_event_type_key, ev->to_input()->input_type());
446
255
249
447
256
    t += 2 * one_frame;  // Account for the slower 59Hz event rate
448
257
    // The motion is still too new. Won't be reported yet, but is batched.
449
258
    // and since batching is locked to the event rate android_input_receiver
450
259
    // will wake up in one frame..
451
260
    EXPECT_TRUE(mt::fd_becomes_readable(receiver.watch_fd(), 2 * one_frame));
250
    EXPECT_TRUE(mt::fd_becomes_readable(receiver.watch_fd(), 2 * one_frame));
452
261
    receiver.dispatch(md::FdEvent::readable);
251
    receiver.dispatch(md::FdEvent::readable);
456
262
252
    EXPECT_EQ(2, handler_called);
454
263
    EXPECT_TRUE(handler_called);
455
264
    EXPECT_EQ(mir_input_event_type_touch, ev->to_input()->input_type());
457
265
}
253
}
458
266
254
459
267
TEST_F(AndroidInputReceiverSetup, finish_signalled_after_handler)
255
TEST_F(AndroidInputReceiverSetup, finish_signalled_after_handler)
460
@@ -287,62 +275,6 @@
461
287
    EXPECT_TRUE(producer.must_receive_handled_signal());
275
    EXPECT_TRUE(producer.must_receive_handled_signal());
462
288
}
276
}
463
289
277
464
290
TEST_F(AndroidInputReceiverSetup, rendering_does_not_lag_behind_input)
465
291
{
466
292
    using namespace testing;
467
293
    using namespace std::chrono;
468
294
    using namespace std::literals::chrono_literals;
469
295
470
296
    std::chrono::nanoseconds t;
471
297
472
298
    int frames_triggered = 0;
473
299
474
300
    mircva::InputReceiver receiver{channel.client_fd(),
475
301
                                   std::make_shared<mircv::XKBMapper>(),
476
302
                                   [&frames_triggered](MirEvent*)
477
303
                                   {
478
304
                                       ++frames_triggered;
479
305
                                   },
480
306
                                   std::make_shared<mircv::NullInputReceiverReport>(),
481
307
                                   [&t](int)
482
308
                                   {
483
309
                                       return t;
484
310
                                   }};
485
311
    TestingInputProducer producer(channel.server_fd());
486
312
487
313
    std::chrono::nanoseconds const device_sample_interval = duration_cast<nanoseconds>(1s) / 250;
488
314
    std::chrono::nanoseconds const frame_interval = duration_cast<nanoseconds>(1s) / 60;
489
315
    std::chrono::nanoseconds const gesture_duration = 1s;
490
316
491
317
    std::chrono::nanoseconds last_produced = 0ns;
492
318
493
319
    for (t = 0ns; t < gesture_duration; t += 1ms)
494
320
    {
495
321
        if (!t.count() || t >= (last_produced + device_sample_interval))
496
322
        {
497
323
            last_produced = t;
498
324
            float a = t.count() * M_PI / 1000000.0f;
499
325
            float x = 500.0f * sinf(a);
500
326
            float y = 1000.0f * cosf(a);
501
327
            producer.produce_a_pointer_event(x, y, t);
502
328
            flush_channels();
503
329
        }
504
330
505
331
        if (mt::fd_is_readable(receiver.watch_fd()))
506
332
        {
507
333
            receiver.dispatch(md::FdEvent::readable);
508
334
        }
509
335
    }
510
336
511
337
    // If the rendering time resulting from the gesture is longer than the
512
338
    // gesture itself then that's laggy...
513
339
    std::chrono::nanoseconds render_duration = frame_interval * frames_triggered;
514
340
    EXPECT_THAT(render_duration, Le(gesture_duration));
515
341
516
342
    int average_lag_milliseconds = (render_duration - gesture_duration) / (frames_triggered * 1ms);
517
343
    EXPECT_THAT(average_lag_milliseconds, Le(1));
518
344
}
519
345
520
346
TEST_F(AndroidInputReceiverSetup, input_comes_in_phase_with_rendering)
278
TEST_F(AndroidInputReceiverSetup, input_comes_in_phase_with_rendering)
521
347
{
279
{
522
348
    using namespace testing;
280
    using namespace testing;
Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration		Approve on 2017-01-17
Andreas Pokorny (community)			Approve on 2017-01-16
Alan Griffiths			Abstain on 2017-01-16
Chris Halse Rogers		2017-01-09	Approve on 2017-01-13
Review via email: mp+314305@code.launchpad.net