1
=== modified file 'src/screen_event_handler.cpp'
2
--- src/screen_event_handler.cpp	2015-07-13 12:35:41 +0000
3
+++ src/screen_event_handler.cpp	2015-11-07 14:07:54 +0000
4
@@ -21,6 +21,7 @@
5
21
#include <mir/time/alarm_factory.h>
21
#include <mir/time/alarm_factory.h>
6
22
#include <mir_toolkit/events/input/input_event.h>
22
#include <mir_toolkit/events/input/input_event.h>
7
23
23
8
24
#include "linux/input.h"
9
24
#include <cstdio>
25
#include <cstdio>
10
25
26
11
26
usc::ScreenEventHandler::ScreenEventHandler(
27
usc::ScreenEventHandler::ScreenEventHandler(
12
@@ -45,8 +46,6 @@
13
45
46
14
46
bool usc::ScreenEventHandler::handle(MirEvent const& event)
47
bool usc::ScreenEventHandler::handle(MirEvent const& event)
15
47
{
48
{
16
48
    static const int32_t POWER_KEY_CODE = 26;
17
49
18
50
    if (mir_event_get_type(&event) != mir_event_type_input)
49
    if (mir_event_get_type(&event) != mir_event_type_input)
19
51
        return false;
50
        return false;
20
52
51
21
@@ -56,14 +55,25 @@
22
56
    if (input_event_type == mir_input_event_type_key)
55
    if (input_event_type == mir_input_event_type_key)
23
57
    {
56
    {
24
58
        auto const kev = mir_input_event_get_keyboard_event(input_event);
57
        auto const kev = mir_input_event_get_keyboard_event(input_event);
33
59
        if (mir_keyboard_event_key_code(kev) != POWER_KEY_CODE)
58
        if (mir_keyboard_event_scan_code(kev) == KEY_POWER)
34
60
            return false;
59
        {
35
61
60
            auto const action = mir_keyboard_event_action(kev);
36
62
        auto const action = mir_keyboard_event_action(kev);
61
            if (action == mir_keyboard_action_down)
37
63
        if (action == mir_keyboard_action_down)
62
                power_key_down();
38
64
            power_key_down();
63
            else if (action == mir_keyboard_action_up)
39
65
        else if (action == mir_keyboard_action_up)
64
                power_key_up();
40
66
            power_key_up();
65
        }
41
66
        // we might want to come up with a whole range of media player related keys
42
67
        else if (mir_keyboard_event_scan_code(kev) == KEY_VOLUMEDOWN||
43
68
                 mir_keyboard_event_scan_code(kev) == KEY_VOLUMEUP)
44
69
        {
45
70
            // do not keep display on when interacting with media player
46
71
        }
47
72
        else
48
73
        {
49
74
            std::lock_guard<std::mutex> lock{guard};
50
75
            screen->keep_display_on_temporarily();
51
76
        }
52
67
    }
77
    }
53
68
    else if (input_event_type == mir_input_event_type_touch ||
78
    else if (input_event_type == mir_input_event_type_touch ||
54
69
             input_event_type == mir_input_event_type_pointer)
79
             input_event_type == mir_input_event_type_pointer)
55
70
80
56
=== modified file 'tests/unit-tests/test_screen_event_handler.cpp'
57
--- tests/unit-tests/test_screen_event_handler.cpp	2015-10-07 12:09:26 +0000
58
+++ tests/unit-tests/test_screen_event_handler.cpp	2015-11-07 14:07:54 +0000
59
@@ -28,6 +28,7 @@
60
28
#include <gtest/gtest.h>
28
#include <gtest/gtest.h>
61
29
#include <gmock/gmock.h>
29
#include <gmock/gmock.h>
62
30
30
63
31
#include "linux/input.h"
64
31
#include <atomic>
32
#include <atomic>
65
32
33
66
33
namespace
34
namespace
67
@@ -64,6 +65,19 @@
68
64
        screen_event_handler.handle(*power_key_up_event);
65
        screen_event_handler.handle(*power_key_up_event);
69
65
    }
66
    }
70
66
67
71
68
    void press_a_key()
72
69
    {
73
70
        screen_event_handler.handle(*another_key_down_event);
74
71
    }
75
72
76
73
    void press_volume_keys()
77
74
    {
78
75
        screen_event_handler.handle(*vol_plus_key_down_event);
79
76
        screen_event_handler.handle(*vol_plus_key_up_event);
80
77
        screen_event_handler.handle(*vol_minus_key_down_event);
81
78
        screen_event_handler.handle(*vol_minus_key_up_event);
82
79
    }
83
80
84
67
    void touch_screen()
81
    void touch_screen()
85
68
    {
82
    {
86
69
        screen_event_handler.handle(*touch_event);
83
        screen_event_handler.handle(*touch_event);
87
@@ -74,21 +88,50 @@
88
74
        screen_event_handler.handle(*pointer_event);
88
        screen_event_handler.handle(*pointer_event);
89
75
    }
89
    }
90
76
90
91
77
    static const int32_t POWER_KEY_CODE = 26;
92
78
    mir::EventUPtr power_key_down_event = mir::events::make_event(
91
    mir::EventUPtr power_key_down_event = mir::events::make_event(
93
79
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
92
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
94
80
	    0, mir_keyboard_action_down,
93
	    0, mir_keyboard_action_down,
96
81
        POWER_KEY_CODE, 0, mir_input_event_modifier_none);
94
        0, KEY_POWER, mir_input_event_modifier_none);
97
82
95
98
83
    mir::EventUPtr power_key_up_event = mir::events::make_event(
96
    mir::EventUPtr power_key_up_event = mir::events::make_event(
99
84
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
97
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
100
85
	    0, mir_keyboard_action_up,
98
	    0, mir_keyboard_action_up,
102
86
        POWER_KEY_CODE, 0, mir_input_event_modifier_none);
99
        0, KEY_POWER, mir_input_event_modifier_none);
103
100
104
101
    mir::EventUPtr vol_plus_key_down_event = mir::events::make_event(
105
102
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
106
103
	    0, mir_keyboard_action_down,
107
104
        0, KEY_VOLUMEUP, mir_input_event_modifier_none);
108
105
109
106
    mir::EventUPtr vol_plus_key_up_event = mir::events::make_event(
110
107
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
111
108
	    0, mir_keyboard_action_up,
112
109
        0, KEY_VOLUMEUP, mir_input_event_modifier_none);
113
110
114
111
    mir::EventUPtr vol_minus_key_down_event = mir::events::make_event(
115
112
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
116
113
	    0, mir_keyboard_action_down,
117
114
        0, KEY_VOLUMEDOWN, mir_input_event_modifier_none);
118
115
119
116
    mir::EventUPtr vol_minus_key_up_event = mir::events::make_event(
120
117
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
121
118
	    0, mir_keyboard_action_up,
122
119
        0, KEY_VOLUMEDOWN, mir_input_event_modifier_none);
123
120
124
121
    mir::EventUPtr another_key_down_event = mir::events::make_event(
125
122
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
126
123
	    0, mir_keyboard_action_down,
127
124
        0, KEY_A, mir_input_event_modifier_none);
128
125
129
126
    mir::EventUPtr another_key_up_event = mir::events::make_event(
130
127
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
131
128
	    0, mir_keyboard_action_up,
132
129
        0, KEY_A, mir_input_event_modifier_none);
133
87
130
134
88
    mir::EventUPtr touch_event = mir::events::make_event(
131
    mir::EventUPtr touch_event = mir::events::make_event(
135
89
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
132
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
136
90
	    0, mir_input_event_modifier_none);
133
	    0, mir_input_event_modifier_none);
138
91
    
134
139
92
    mir::EventUPtr pointer_event = mir::events::make_event(
135
    mir::EventUPtr pointer_event = mir::events::make_event(
140
93
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
136
        MirInputDeviceId{1}, std::chrono::nanoseconds(0),
141
94
	    0, mir_input_event_modifier_none,
137
	    0, mir_input_event_modifier_none,
142
@@ -167,6 +210,20 @@
143
167
    move_pointer();
210
    move_pointer();
144
168
}
211
}
145
169
212
146
213
TEST_F(AScreenEventHandler, keeps_display_on_temporarily_on_other_keys)
147
214
{
148
215
    EXPECT_CALL(mock_screen, keep_display_on_temporarily());
149
216
150
217
    press_a_key();
151
218
}
152
219
153
220
TEST_F(AScreenEventHandler, does_not_keep_display_on_for_volume_keys)
154
221
{
155
222
    EXPECT_CALL(mock_screen, keep_display_on_temporarily()).Times(0);
156
223
157
224
    press_volume_keys();
158
225
}
159
226
160
170
TEST_F(AScreenEventHandler, sets_screen_mode_off_normal_press_release)
227
TEST_F(AScreenEventHandler, sets_screen_mode_off_normal_press_release)
161
171
{
228
{
162
172
    EXPECT_CALL(mock_screen,
229
    EXPECT_CALL(mock_screen,
Reviewer	Review Type	Date Requested	Status
Alexandros Frantzis (community)		2015-11-07	Approve on 2015-12-01
PS Jenkins bot (community)	continuous-integration		Approve on 2015-12-01
Review via email: mp+276925@code.launchpad.net