git.iko.soy/unity8
on xenial help sign in
Refactor to use signals
376c593Michał Sawicz
qml/Components/PhysicalKeysMapper.qml+33−23
compare with xenial
unifiedsplit
@@ -35,17 +35,17 @@ import Powerd 0.1
35Item {
35Item {
36 id: root
36 id: root
37
37
38− signal powerKeyLongPress();
38+ signal powerKeyLongPress;
39−
39+ signal volumeDownTrigger;
40− property bool screenshotPressed: d.volumeUpKeyPressed && d.volumeDownKeyPressed
40+ signal volumeUpTrigger;
41− property bool volumeDownPressed: d.volumeDownKeyPressed && !d.volumeUpKeyPressed
41+ signal screenshotTrigger;
42− property bool volumeUpPressed: d.volumeUpKeyPressed && !d.volumeDownKeyPressed
43
42
44 QtObject {
43 QtObject {
45 id: d
44 id: d
46
45
47 property bool volumeDownKeyPressed: false
46 property bool volumeDownKeyPressed: false
48 property bool volumeUpKeyPressed: false
47 property bool volumeUpKeyPressed: false
48+ property bool ignoreVolumeEvents: false
49 }
49 }
50
50
51 Timer {
51 Timer {
@@ -57,10 +57,9 @@ Item {
57
57
58
58
59 function onKeyPressed(event) {
59 function onKeyPressed(event) {
60− var eventAccepted = false;
61−
62 /* Determine what key was pressed */
60 /* Determine what key was pressed */
63− if (event.key == Qt.Key_PowerDown || event.key == Qt.Key_PowerOff) {
61+ if ((event.key == Qt.Key_PowerDown || event.key == Qt.Key_PowerOff)
62+ && !event.isAutoRepeat) {
64
63
65 // FIXME: We only consider power key presses if the screen is
64 // FIXME: We only consider power key presses if the screen is
66 // on because of bugs 1410830/1409003. The theory is that when
65 // on because of bugs 1410830/1409003. The theory is that when
@@ -71,34 +70,45 @@ Item {
71 // initiate any dialogs when the screen is off.
70 // initiate any dialogs when the screen is off.
72 // This also prevents taking screenshots when the screen is off.
71 // This also prevents taking screenshots when the screen is off.
73 if (Powerd.status === Powerd.On) {
72 if (Powerd.status === Powerd.On) {
74− if (!event.isAutoRepeat) {
75− powerKeyLongPressTimer.restart();
73+ powerKeyLongPressTimer.restart();
76− }
74+ event.accepted = true;
77− eventAccepted = true;
78 }
75 }
79− } else if (event.key == Qt.Key_MediaTogglePlayPause || event.key == Qt.Key_MediaPlay) {
76+ } else if ((event.key == Qt.Key_MediaTogglePlayPause || event.key == Qt.Key_MediaPlay)
77+ && !event.isAutoRepeat) {
80− eventAccepted = callManager.handleMediaKey(false);
78+ event.accepted = callManager.handleMediaKey(false);
81 } else if (event.key == Qt.Key_VolumeDown) {
79 } else if (event.key == Qt.Key_VolumeDown) {
80+ if (event.isAutoRepeat && !d.ignoreVolumeEvents) root.volumeDownTrigger();
81+ else if (!event.isAutoRepeat) {
82+ if (d.volumeUpKeyPressed) {
83+ root.screenshotTrigger();
84+ d.ignoreVolumeEvents = true;
85+ }
82− d.volumeDownKeyPressed = true;
86+ d.volumeDownKeyPressed = true;
87+ }
83 } else if (event.key == Qt.Key_VolumeUp) {
88 } else if (event.key == Qt.Key_VolumeUp) {
89+ if (event.isAutoRepeat && !d.ignoreVolumeEvents) root.volumeUpTrigger();
90+ else if (!event.isAutoRepeat) {
91+ if (d.volumeDownKeyPressed) {
92+ root.screenshotTrigger();
93+ d.ignoreVolumeEvents = true;
94+ }
84− d.volumeUpKeyPressed = true;
95+ d.volumeUpKeyPressed = true;
96+ }
85 }
97 }
86−
87− return eventAccepted;
88 }
98 }
89
99
90 function onKeyReleased(event) {
100 function onKeyReleased(event) {
91− var eventAccepted = false;
92−
93 if (event.key == Qt.Key_PowerDown || event.key == Qt.Key_PowerOff) {
101 if (event.key == Qt.Key_PowerDown || event.key == Qt.Key_PowerOff) {
94 powerKeyLongPressTimer.stop();
102 powerKeyLongPressTimer.stop();
95− eventAccepted = true;
103+ event.accepted = true;
96 } else if (event.key == Qt.Key_VolumeDown) {
104 } else if (event.key == Qt.Key_VolumeDown) {
105+ if (!d.ignoreVolumeEvents) root.volumeDownTrigger();
97 d.volumeDownKeyPressed = false;
106 d.volumeDownKeyPressed = false;
107+ if (!d.volumeUpKeyPressed) d.ignoreVolumeEvents = false;
98 } else if (event.key == Qt.Key_VolumeUp) {
108 } else if (event.key == Qt.Key_VolumeUp) {
109+ if (!d.ignoreVolumeEvents) root.volumeUpTrigger();
99 d.volumeUpKeyPressed = false;
110 d.volumeUpKeyPressed = false;
111+ if (!d.volumeDownKeyPressed) d.ignoreVolumeEvents = false;
100 }
112 }
101−
102− return eventAccepted;
103 }
113 }
104}
114}
qml/Shell.qml+5−11
@@ -164,10 +164,9 @@ Item {
164 id: physicalKeysMapper
164 id: physicalKeysMapper
165
165
166 onPowerKeyLongPress: dialogs.showPowerDialog()
166 onPowerKeyLongPress: dialogs.showPowerDialog()
167− onVolumeDownPressedChanged: if (volumeDownPressed) { volumeControl.volumeDown(); }
167+ onVolumeDownTriggered: volumeControl.volumeDown();
168− onVolumeUpPressedChanged: if (volumeUpPressed) { volumeControl.volumeUp(); }
168+ onVolumeUpTriggered: volumeControl.volumeUp();
169− onScreenshotPressedChanged: if (screenshotPressed) { screenGrabber.capture(); }
169+ onScreenshotTriggered: screenGrabber.capture();
170−
171 }
170 }
172
171
173 ScreenGrabber {
172 ScreenGrabber {
@@ -183,13 +182,8 @@ Item {
183 }
182 }
184
183
185 WindowKeysFilter {
184 WindowKeysFilter {
186− Keys.onPressed: {
187− event.accepted = physicalKeysMapper.onKeyPressed(event);
185+ Keys.onPressed: physicalKeysMapper.onKeyPressed(event);
188− }
189−
190− Keys.onReleased: {
191− event.accepted = physicalKeysMapper.onKeyReleased(event);
186+ Keys.onReleased: physicalKeysMapper.onKeyReleased(event);
192− }
193 }
187 }
194
188
195 Item {
189 Item {
tests/qmltests/Components/tst_PhysicalKeysMapper.qml+57−30
@@ -21,61 +21,88 @@ import "../../../qml/Components"
21TestCase {
21TestCase {
22 name: "PhysicalKeysMapper"
22 name: "PhysicalKeysMapper"
23
23
24− PhysicalKeysMapper {
24+ Loader {
25− id: physicalKeysMapper
25+ id: loader
26+ active: false
27+ sourceComponent: PhysicalKeysMapper { }
26 }
28 }
27
29
28 SignalSpy {
30 SignalSpy {
29 id: powerSpy
31 id: powerSpy
30− target: physicalKeysMapper
32+ target: loader.item
31 signalName: "powerKeyLongPress"
33 signalName: "powerKeyLongPress"
32 }
34 }
33
35
36+ SignalSpy {
37+ id: volumeDownSpy
38+ target: loader.item
39+ signalName: "volumeDownTrigger"
40+ }
41+
42+ SignalSpy {
43+ id: volumeUpSpy
44+ target: loader.item
45+ signalName: "volumeUpTrigger"
46+ }
47+
48+ SignalSpy {
49+ id: screenshotSpy
50+ target: loader.item
51+ signalName: "screenshotTrigger"
52+ }
53+
34− function cleanup() {
54+ function init() {
35− physicalKeysMapper.onKeyReleased({ key: Qt.Key_PowerDown });
55+ loader.active = true;
36− physicalKeysMapper.onKeyReleased({ key: Qt.Key_VolumeDown });
56+ tryCompare(loader.status == Loader.Ready);
37− physicalKeysMapper.onKeyReleased({ key: Qt.Key_VolumeUp });
57+ }
38
58
59+ function cleanup() {
60+ loader.active = false;
39 powerSpy.clear();
61 powerSpy.clear();
62+ volumeDownSpy.clear();
63+ volumeUpSpy.clear();
64+ screenshotSpy.clear();
40 }
65 }
41
66
42 function test_LongPressPowerButton() {
67 function test_LongPressPowerButton() {
43− physicalKeysMapper.onKeyPressed({ key: Qt.Key_PowerDown });
68+ loader.item.onKeyPressed({ key: Qt.Key_PowerDown });
44
69
45 expectFailContinue("", "Power signal should not be emitted within a second");
70 expectFailContinue("", "Power signal should not be emitted within a second");
46 powerSpy.wait(1000);
71 powerSpy.wait(1000);
47 powerSpy.clear();
72 powerSpy.clear();
48
73
49− physicalKeysMapper.onKeyPressed({ key: Qt.Key_PowerDown, isAutoRepeat: true });
74+ loader.item.onKeyPressed({ key: Qt.Key_PowerDown, isAutoRepeat: true });
50 powerSpy.wait(1500);
75 powerSpy.wait(1500);
51 }
76 }
52
77
78+ function test_ScreenshotButtons_data() {
79+ return [
80+ { tag: "UpFirst", first: Qt.Key_VolumeUp, second: Qt.Key_VolumeDown },
81+ { tag: "DownFirst", first: Qt.Key_VolumeDown, second: Qt.Key_VolumeUp },
82+ ];
83+ }
84+
53− function test_ScreenshotButtons() {
85+ function test_ScreenshotButtons(data) {
54− /* Behavior when VolumeUp is pressed 1st */
86+ loader.item.onKeyPressed({ key: data.first });
55− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeUp });
87+ loader.item.onKeyPressed({ key: data.second });
56− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeDown });
88+ screenshotSpy.wait();
57− compare(physicalKeysMapper.screenshotPressed, true);
89+ loader.item.onKeyReleased({ key: data.first });
58− compare(physicalKeysMapper.volumeDownPressed, false);
90+ loader.item.onKeyReleased({ key: data.second });
59−
91+ expectFailContinue("", "VolumeUp signal should not fire");
60− physicalKeysMapper.onKeyReleased({ key: Qt.Key_VolumeUp });
92+ volumeUpSpy.wait(100);
61− physicalKeysMapper.onKeyReleased({ key: Qt.Key_VolumeDown });
93+ expectFailContinue("", "VolumeDown signal should not fire");
62−
94+ volumeDownSpy.wait(100);
63− /* Behavior when VolumeDown is pressed 1st */
64− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeDown });
65− compare(physicalKeysMapper.volumeDownPressed, true);
66− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeUp });
67− compare(physicalKeysMapper.screenshotPressed, true);
68 }
95 }
69
96
70 function test_VolumeDownButton() {
97 function test_VolumeDownButton() {
71− compare(physicalKeysMapper.volumeDownPressed, false);
72− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeDown });
98+ loader.item.onKeyPressed({ key: Qt.Key_VolumeDown });
73− compare(physicalKeysMapper.volumeDownPressed, true);
99+ loader.item.onKeyReleased({ key: Qt.Key_VolumeDown });
100+ volumeDownSpy.wait();
74 }
101 }
75
102
76 function test_VolumeUpButton() {
103 function test_VolumeUpButton() {
77− compare(physicalKeysMapper.volumeUpPressed, false);
78− physicalKeysMapper.onKeyPressed({ key: Qt.Key_VolumeUp });
104+ loader.item.onKeyPressed({ key: Qt.Key_VolumeUp });
79− compare(physicalKeysMapper.volumeUpPressed, true);
105+ loader.item.onKeyReleased({ key: Qt.Key_VolumeUp });
106+ volumeUpSpy.wait();
80 }
107 }
81}
108}