← Back to branch summary

~ubuntu-branches/ubuntu/wily/mir/wily-proposed

« back to all changes in this revision

Viewing changes to tests/mir_test_doubles/fake_event_hub.cpp

  • Committer: Package Import Robot
  • Author(s): CI Train Bot
  • Date: 2015-05-12 13:12:55 UTC
  • mto: This revision was merged to the branch mainline in revision 96.
  • Revision ID: package-import@ubuntu.com-20150512131255-y7z12i8n4pbvo70x
Tags: upstream-0.13.0+15.10.20150512
Import upstream version 0.13.0+15.10.20150512

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/mir_test_doubles/fake_event_hub.cpp
16
16
 */
17
17
#include "mir_test/fake_event_hub.h"
18
18
 
 
19
#include "mir/log.h"
 
20
#include "mir/logging/logger.h"
 
21
 
19
22
// from android-input
20
23
#include <androidfw/Keyboard.h>
21
24
#include <std/Errors.h>
23
26
#include <thread>
24
27
#include <chrono>
25
28
 
 
29
#include <sys/eventfd.h>
 
30
 
26
31
using droidinput::AxisInfo;
27
32
using droidinput::InputDeviceIdentifier;
28
33
using droidinput::PropertyMap;
51
56
int const FakeEventHub::TouchScreenMaxAxisValue = 100;
52
57
 
53
58
FakeEventHub::FakeEventHub()
 
59
    : trigger_fd{eventfd(0, EFD_CLOEXEC|EFD_NONBLOCK)}
54
60
{
55
61
    keymap.loadGenericMaps();
56
62
}
219
225
    excluded_devices = devices;
220
226
}
221
227
 
222
 
size_t FakeEventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize)
 
228
size_t FakeEventHub::getEvents(RawEvent* buffer, size_t bufferSize)
223
229
{
224
230
    size_t num_events_obtained = 0;
225
 
    (void) timeoutMillis;
226
231
    {
227
232
        std::lock_guard<std::mutex> lg(guard);
 
233
        uint64_t dummy;
 
234
        if (sizeof dummy != read(trigger_fd, &dummy, sizeof dummy))
 
235
            mir::log(mir::logging::Severity::debug, "FakeEventHub", "No event trigger to consume");
228
236
 
229
237
        if (throw_in_get_events)
230
238
            throw std::runtime_error("FakeEventHub::getEvents() exception");
404
412
{
405
413
}
406
414
 
 
415
void FakeEventHub::wakeIn(int32_t)
 
416
{
 
417
}
 
418
 
407
419
void FakeEventHub::wake()
408
420
{
 
421
    uint64_t one{1};
 
422
    if (sizeof one != write(trigger_fd, &one, sizeof one))
 
423
        BOOST_THROW_EXCEPTION((std::system_error{errno,
 
424
                               std::system_category(),
 
425
                               "Failed to wake fake event hub"}));
 
426
}
 
427
 
 
428
void FakeEventHub::wake(droidinput::RawEvent const& event)
 
429
{
 
430
    std::lock_guard<std::mutex> lg(guard);
 
431
    events_available.push_back(event);
 
432
    wake();
409
433
}
410
434
 
411
435
void FakeEventHub::dump(droidinput::String8& dump)
421
445
{
422
446
}
423
447
 
 
448
mir::Fd FakeEventHub::fd()
 
449
{
 
450
    return trigger_fd;
 
451
}
 
452
 
424
453
void FakeEventHub::synthesize_builtin_keyboard_added()
425
454
{
426
455
    RawEvent event;
428
457
    event.deviceId = BuiltInKeyboardID;
429
458
    event.type = EventHubInterface::DEVICE_ADDED;
430
459
 
431
 
    std::lock_guard<std::mutex> lg(guard);
432
 
    events_available.push_back(event);
 
460
    wake(event);
433
461
}
434
462
 
435
463
void FakeEventHub::synthesize_builtin_cursor_added()
439
467
    event.deviceId = BuiltInCursorID;
440
468
    event.type = EventHubInterface::DEVICE_ADDED;
441
469
 
442
 
    std::lock_guard<std::mutex> lg(guard);
443
 
    events_available.push_back(event);
 
470
    wake(event);
444
471
}
445
472
 
446
473
void FakeEventHub::synthesize_usb_touchscreen_added()
469
496
    
470
497
    std::lock_guard<std::mutex> lg(guard);
471
498
    events_available.push_back(event);
 
499
    wake();
472
500
}
473
501
 
474
502
void FakeEventHub::synthesize_device_scan_complete()
477
505
    event.when = std::chrono::nanoseconds(0);
478
506
    event.type = EventHubInterface::FINISHED_DEVICE_SCAN;
479
507
 
480
 
    std::lock_guard<std::mutex> lg(guard);
481
 
    events_available.push_back(event);
 
508
    wake(event);
482
509
}
483
510
 
484
511
void FakeEventHub::synthesize_event(const mis::KeyParameters &parameters)
498
525
    else
499
526
        event.value = 0;
500
527
 
501
 
    std::lock_guard<std::mutex> lg(guard);
502
 
    events_available.push_back(event);
 
528
    wake(event);
503
529
}
504
530
 
505
531
void FakeEventHub::synthesize_event(const mis::ButtonParameters &parameters)
526
552
    event.type = EV_SYN;
527
553
    event.code = SYN_REPORT;
528
554
    events_available.push_back(event);
 
555
    wake();
529
556
}
530
557
 
531
558
void FakeEventHub::synthesize_event(const mis::MotionParameters &parameters)
551
578
    event.type = EV_SYN;
552
579
    event.code = SYN_REPORT;
553
580
    events_available.push_back(event);
 
581
    wake();
554
582
}
555
583
 
556
584
void FakeEventHub::synthesize_event(const mis::TouchParameters &parameters)
584
612
    event.type = EV_SYN;
585
613
    event.code = SYN_REPORT;
586
614
    events_available.push_back(event);
 
615
    wake();
587
616
}
588
617
 
589
618
void FakeEventHub::synthesize_event(std::chrono::nanoseconds when, int32_t device_id, int32_t type, int32_t code, int32_t value)
595
624
    event.code = code;
596
625
    event.value = value;
597
626
 
598
 
    {
599
 
        std::lock_guard<std::mutex> lg(guard);
600
 
        events_available.push_back(event);
601
 
    }
 
627
    wake(event);
602
628
 
603
629
    if (type == EV_ABS)
604
630
    {
763
789
{
764
790
    std::lock_guard<std::mutex> lg(guard);
765
791
    throw_in_get_events = true;
 
792
    wake();
766
793
}