Как узнать, когда пользователь действительно выпустил ключ в Java?
(Отредактировано для ясности)
Я хочу определить, когда пользователь нажимает и отпускает клавишу в Java Swing, игнорируя функцию автоматического повтора клавиатуры. Я также хотел бы, чтобы подход на основе чистого Java работал на Linux, Mac OS и Windows.
Требования:
- Когда пользователь нажимает какую-то клавишу, я хочу знать, что это за клавиша;
- Когда пользователь отпускает какой-то ключ, я хочу знать, что это за ключ;
- Я хочу игнорировать параметры автоматического повторения системы: я хочу получать только одно событие нажатия клавиши для каждого нажатия клавиши и только одно событие отпускания клавиши для каждого нажатия клавиши;
- Если возможно, я бы использовал пункты с 1 по 3, чтобы узнать, удерживает ли пользователь более одной клавиши за раз (т. Е. Она нажимает "а" и, не отпуская ее, нажимает "Ввод").
Проблема, с которой я сталкиваюсь в Java, заключается в том, что в Linux, когда пользователь удерживает какую-либо клавишу, происходит много событий keyPress и keyRelease (из-за функции повторения клавиатуры).
Я пробовал некоторые подходы без успеха:
- Получите последний раз, когда произошло ключевое событие - в Linux они кажутся равными нулю для повторения ключа, однако в Mac OS их нет;
- Рассматривайте событие только в том случае, если текущий код ключа отличается от последнего - таким образом, пользователь не может дважды нажать один и тот же ключ подряд;
Вот основная (не рабочая) часть кода:
import java.awt.event.KeyListener;
public class Example implements KeyListener {
public void keyTyped(KeyEvent e) {
}
public void keyPressed(KeyEvent e) {
System.out.println("KeyPressed: "+e.getKeyCode()+", ts="+e.getWhen());
}
public void keyReleased(KeyEvent e) {
System.out.println("KeyReleased: "+e.getKeyCode()+", ts="+e.getWhen());
}
}
Когда пользователь держит ключ (то есть "p"), система показывает:
KeyPressed: 80, ts=1253637271673
KeyReleased: 80, ts=1253637271923
KeyPressed: 80, ts=1253637271923
KeyReleased: 80, ts=1253637271956
KeyPressed: 80, ts=1253637271956
KeyReleased: 80, ts=1253637271990
KeyPressed: 80, ts=1253637271990
KeyReleased: 80, ts=1253637272023
KeyPressed: 80, ts=1253637272023
...
По крайней мере, в Linux JVM продолжает пересылать все ключевые события, когда клавиша удерживается. Чтобы усложнить задачу, в моей системе (Kubuntu 9.04 Core 2 Duo) временные метки постоянно меняются. JVM отправляет ключу новую версию и нажатие новой клавиши с той же отметкой времени. Это затрудняет определение того, когда ключ действительно выпущен.
Есть идеи?
Спасибо
10 ответов
Это может быть проблематично. Я не могу вспомнить наверняка (это было давно), но, скорее всего, функция повторяющегося ключа (которая обрабатывается базовой операционной системой, а не Java) не предоставляет достаточной информации для разработчика JVM, чтобы различить эти дополнительные ключевые события от "настоящего". (Я работал над этим в OS/2 AWT еще в 1.1.x, кстати).
Из Javadoc для KeyEvent:
События "нажатие клавиши" и "отпускание клавиши" являются низкоуровневыми и зависят от платформы и раскладки клавиатуры. Они генерируются всякий раз, когда клавиша нажимается или отпускается, и являются единственным способом узнать о клавишах, которые не генерируют ввод символов (например, клавиши действий, клавиши-модификаторы и т. Д.). Нажимаемая или отпускаемая клавиша указывается методом getKeyCode, который возвращает код виртуальной клавиши.
Как я помню из этого, в OS/2 (который в то время все еще имел только 2 варианта события вверх / вниз при работе с клавиатурой, как в старых версиях Windows), а не 3 варианта события вверх / вниз / символ, который вы получаете в более современные версии), я не сообщал о событиях KeyReleased иначе, если ключ просто удерживался и события генерировались автоматически; но я подозреваю, что OS / 2 даже не сообщала мне эту информацию (точно не помню). Мы использовали эталонную JVM для Windows от Sun в качестве руководства для разработки нашего AWT - поэтому я подозреваю, что если бы можно было сообщить эту информацию там, я бы хотя бы увидел ее с их стороны.
Этот вопрос продублирован здесь.
В этом вопросе дается ссылка на парад ошибок Sun, где предлагается какой-то обходной путь.
Я сделал хак, реализованный в виде AWTEventListener, который можно установить в начале приложения.
В основном, обратите внимание, что время между RELEASED и последующим PRESSED мало - на самом деле это 0 миллис. Таким образом, вы можете использовать это как меру: удерживайте RELEASED в течение некоторого времени, и, если сразу после этого появится новый PRESSED, затем проглотите RELEASED и просто обработайте PRESSED (и, таким образом, вы получите ту же логику, что и в Windows, которая, очевидно, это правильный путь). Тем не менее, следите за переходом с одной миллисекунды на другую (я видел, как это происходило), поэтому используйте по крайней мере 1 мс для проверки. Чтобы учесть задержки и много чего, около 20-30 миллисекунд, вероятно, не повредят.
Я усовершенствовал хак для stolsvik, чтобы предотвратить повторение событий KEY_PRESSED и KEY_TYPED, с этим уточнением он работает правильно под Win7 (должен работать везде, так как он действительно следит за событиями KEY_PRESSED/KEY_TYPED/KEY_RELEASED).
Ура! Якуб
package com.example;
import java.awt.AWTEvent;
import java.awt.Component;
import java.awt.EventQueue;
import java.awt.Toolkit;
import java.awt.event.AWTEventListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import javax.swing.Timer;
/**
* This {@link AWTEventListener} tries to work around for KEY_PRESSED / KEY_TYPED/ KEY_RELEASED repeaters.
*
* If you wish to obtain only one pressed / typed / released, no repeatings (i.e., when the button is hold for a long time).
* Use new RepeatingKeyEventsFixer().install() as a first line in main() method.
*
* Based on xxx
* Which was done by Endre Stølsvik and inspired by xxx (hyperlinks stipped out due to stackru policies)
*
* Refined by Jakub Gemrot not only to fix KEY_RELEASED events but also KEY_PRESSED and KEY_TYPED repeatings. Tested under Win7.
*
* If you wish to test the class, just uncomment all System.out.println(...)s.
*
* @author Endre Stølsvik
* @author Jakub Gemrot
*/
public class RepeatingKeyEventsFixer implements AWTEventListener {
public static final int RELEASED_LAG_MILLIS = 5;
private static boolean assertEDT() {
if (!EventQueue.isDispatchThread()) {
throw new AssertionError("Not EDT, but [" + Thread.currentThread() + "].");
}
return true;
}
private Map<Integer, ReleasedAction> _releasedMap = new HashMap<Integer, ReleasedAction>();
private Set<Integer> _pressed = new HashSet<Integer>();
private Set<Character> _typed = new HashSet<Character>();
public void install() {
Toolkit.getDefaultToolkit().addAWTEventListener(this, AWTEvent.KEY_EVENT_MASK);
}
public void remove() {
Toolkit.getDefaultToolkit().removeAWTEventListener(this);
}
@Override
public void eventDispatched(AWTEvent event) {
assert event instanceof KeyEvent : "Shall only listen to KeyEvents, so no other events shall come here";
assert assertEDT(); // REMEMBER THAT THIS IS SINGLE THREADED, so no need
// for synch.
// ?: Is this one of our synthetic RELEASED events?
if (event instanceof Reposted) {
//System.out.println("REPOSTED: " + ((KeyEvent)event).getKeyChar());
// -> Yes, so we shalln't process it again.
return;
}
final KeyEvent keyEvent = (KeyEvent) event;
// ?: Is this already consumed?
// (Note how events are passed on to all AWTEventListeners even though a
// previous one consumed it)
if (keyEvent.isConsumed()) {
return;
}
// ?: KEY_TYPED event? (We're only interested in KEY_PRESSED and
// KEY_RELEASED).
if (event.getID() == KeyEvent.KEY_TYPED) {
if (_typed.contains(keyEvent.getKeyChar())) {
// we're being retyped -> prevent!
//System.out.println("TYPED: " + keyEvent.getKeyChar() + " (CONSUMED)");
keyEvent.consume();
} else {
// -> Yes, TYPED, for a first time
//System.out.println("TYPED: " + keyEvent.getKeyChar());
_typed.add(keyEvent.getKeyChar());
}
return;
}
// ?: Is this RELEASED? (the problem we're trying to fix!)
if (keyEvent.getID() == KeyEvent.KEY_RELEASED) {
// -> Yes, so stick in wait
/*
* Really just wait until "immediately", as the point is that the
* subsequent PRESSED shall already have been posted on the event
* queue, and shall thus be the direct next event no matter which
* events are posted afterwards. The code with the ReleasedAction
* handles if the Timer thread actually fires the action due to
* lags, by cancelling the action itself upon the PRESSED.
*/
final Timer timer = new Timer(RELEASED_LAG_MILLIS, null);
ReleasedAction action = new ReleasedAction(keyEvent, timer);
timer.addActionListener(action);
timer.start();
ReleasedAction oldAction = (ReleasedAction)_releasedMap.put(Integer.valueOf(keyEvent.getKeyCode()), action);
if (oldAction != null) oldAction.cancel();
// Consume the original
keyEvent.consume();
//System.out.println("RELEASED: " + keyEvent.getKeyChar() + " (CONSUMED)");
return;
}
if (keyEvent.getID() == KeyEvent.KEY_PRESSED) {
if (_pressed.contains(keyEvent.getKeyCode())) {
// we're still being pressed
//System.out.println("PRESSED: " + keyEvent.getKeyChar() + " (CONSUMED)");
keyEvent.consume();
} else {
// Remember that this is single threaded (EDT), so we can't have
// races.
ReleasedAction action = (ReleasedAction) _releasedMap.get(keyEvent.getKeyCode());
// ?: Do we have a corresponding RELEASED waiting?
if (action != null) {
// -> Yes, so dump it
action.cancel();
}
_pressed.add(keyEvent.getKeyCode());
//System.out.println("PRESSED: " + keyEvent.getKeyChar());
}
return;
}
throw new AssertionError("All IDs should be covered.");
}
/**
* The ActionListener that posts the RELEASED {@link RepostedKeyEvent} if
* the {@link Timer} times out (and hence the repeat-action was over).
*/
protected class ReleasedAction implements ActionListener {
private final KeyEvent _originalKeyEvent;
private Timer _timer;
ReleasedAction(KeyEvent originalReleased, Timer timer) {
_timer = timer;
_originalKeyEvent = originalReleased;
}
void cancel() {
assert assertEDT();
_timer.stop();
_timer = null;
_releasedMap.remove(Integer.valueOf(_originalKeyEvent.getKeyCode()));
}
@Override
public void actionPerformed(@SuppressWarnings("unused") ActionEvent e) {
assert assertEDT();
// ?: Are we already cancelled?
// (Judging by Timer and TimerQueue code, we can theoretically be
// raced to be posted onto EDT by TimerQueue,
// due to some lag, unfair scheduling)
if (_timer == null) {
// -> Yes, so don't post the new RELEASED event.
return;
}
//System.out.println("REPOST RELEASE: " + _originalKeyEvent.getKeyChar());
// Stop Timer and clean.
cancel();
// Creating new KeyEvent (we've consumed the original).
KeyEvent newEvent = new RepostedKeyEvent(
(Component) _originalKeyEvent.getSource(),
_originalKeyEvent.getID(), _originalKeyEvent.getWhen(),
_originalKeyEvent.getModifiers(), _originalKeyEvent
.getKeyCode(), _originalKeyEvent.getKeyChar(),
_originalKeyEvent.getKeyLocation());
// Posting to EventQueue.
_pressed.remove(_originalKeyEvent.getKeyCode());
_typed.remove(_originalKeyEvent.getKeyChar());
Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(newEvent);
}
}
/**
* Marker interface that denotes that the {@link KeyEvent} in question is
* reposted from some {@link AWTEventListener}, including this. It denotes
* that the event shall not be "hack processed" by this class again. (The
* problem is that it is not possible to state
* "inject this event from this point in the pipeline" - one have to inject
* it to the event queue directly, thus it will come through this
* {@link AWTEventListener} too.
*/
public interface Reposted {
// marker
}
/**
* Dead simple extension of {@link KeyEvent} that implements
* {@link Reposted}.
*/
public static class RepostedKeyEvent extends KeyEvent implements Reposted {
public RepostedKeyEvent(@SuppressWarnings("hiding") Component source,
@SuppressWarnings("hiding") int id, long when, int modifiers,
int keyCode, char keyChar, int keyLocation) {
super(source, id, when, modifiers, keyCode, keyChar, keyLocation);
}
}
}
Я нашел решение этой проблемы, не полагаясь на время (которое, по мнению некоторых пользователей, не обязательно соответствует 100% времени), а вместо этого путем выдачи дополнительных нажатий клавиш для отмены повторения клавиш.
Чтобы понять, что я имею в виду, попробуйте удерживать клавишу, а затем нажать другую середину потока. Повтор остановится. Кажется, что, по крайней мере, в моей системе ключевые нажатия, выпущенные роботом, также имеют такой эффект.
Пример реализации, протестированный в Windows 7 и Ubuntu, смотрите:
http://elionline.co.uk/blog/2012/07/12/ignore-key-repeats-in-java-swing-independently-of-platform/
Кроме того, спасибо решению Эндре Столсвика за то, что он показал мне, как сделать слушатель глобального события! Оценил.
Сохранить метку времени события (arg0.when()) в keyReleased, Если следующий keyPressed событие для того же ключа и имеет ту же метку времени, это автоповтор.
Если вы удерживаете несколько клавиш, X11 автоматически повторяет только последнюю нажатую клавишу. Итак, если вы удерживаете "а" и "d", вы увидите что-то вроде:
a down
a up
a down
d down
d up
d down
d up
a up
Я нашел решение, которое обходится без ожидания, если у вас что-то вроде игрового цикла. Идея хранения событий релиза. Затем вы можете проверить их как внутри игрового цикла, так и внутри обработчика нажатой клавиши. Под "(не) зарегистрировать ключ" я подразумеваю извлеченные истинные события пресс-релиза, которые должны обрабатываться приложением. Позаботьтесь о синхронизации при выполнении следующих действий!
- на событиях выпуска: сохраните событие для ключа; иначе ничего не делать!
- о событиях прессы: если нет сохраненного события релиза, это новое нажатие -> зарегистрировать его; если в течение 5 мс сохранено событие, это автоповторение -> удалить событие освобождения; в противном случае у нас есть сохраненное событие релиза, которое не было очищено игровым циклом, но -> (быстрый пользователь) делает, как вам нравится, например, unregister-register
- в вашем цикле: проверьте сохраненные события релиза и рассматривайте те, которые старше 5 мс, как истинные релизы; отменить их регистрацию; обрабатывать все зарегистрированные ключи
Возможно, вы захотите использовать карту действий интересующего вас компонента. Вот пример, который имеет дело с конкретным ключом (пробел), но я уверен, что если вы прочитаете документацию, вы сможете изменить его для обработки универсального ключевые нажатия и релизы.
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeListener;
import javax.swing.Action;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.KeyStroke;
public class Main {
public static void main(String[] args) {
JFrame f = new JFrame("Test");
JPanel c = new JPanel();
c.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(
KeyStroke.getKeyStroke("SPACE"), "pressed");
c.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(
KeyStroke.getKeyStroke("released SPACE"), "released");
c.getActionMap().put("pressed", new Action() {
public void addPropertyChangeListener(
PropertyChangeListener listener) {
}
public Object getValue(String key) {
return null;
}
public boolean isEnabled() {
return true;
}
public void putValue(String key, Object value) {
}
public void removePropertyChangeListener(
PropertyChangeListener listener) {
}
public void setEnabled(boolean b) {
}
public void actionPerformed(ActionEvent e) {
System.out.println("Pressed space at "+System.nanoTime());
}
});
c.getActionMap().put("released", new Action() {
public void addPropertyChangeListener(
PropertyChangeListener listener) {
}
public Object getValue(String key) {
return null;
}
public boolean isEnabled() {
return true;
}
public void putValue(String key, Object value) {
}
public void removePropertyChangeListener(
PropertyChangeListener listener) {
}
public void setEnabled(boolean b) {
}
public void actionPerformed(ActionEvent e) {
System.out.println("Released space at "+System.nanoTime());
}
});
c.setPreferredSize(new Dimension(200,200));
f.getContentPane().add(c);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.pack();
f.setVisible(true);
}
}
Этот подход сохраняет нажатия клавиш в HashMap, сбрасывая их при отпускании ключа. Большая часть кода предоставлена Elist в этом посте.
import java.awt.KeyEventDispatcher;
import java.awt.KeyboardFocusManager;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
public class KeyboardInput2 {
private static HashMap<Integer, Boolean> pressed = new HashMap<Integer, Boolean>();
public static boolean isPressed(int key) {
synchronized (KeyboardInput2.class) {
return pressed.get(key);
}
}
public static void allPressed() {
final Set<Integer> templist = pressed.keySet();
if (templist.size() > 0) {
System.out.println("Key(s) logged: ");
}
for (int key : templist) {
System.out.println(KeyEvent.getKeyText(key));
}
}
public static void main(String[] args) {
KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(new KeyEventDispatcher() {
@Override
public boolean dispatchKeyEvent(KeyEvent ke) {
synchronized (KeyboardInput2.class) {
switch (ke.getID()) {
case KeyEvent.KEY_PRESSED:
pressed.put(ke.getKeyCode(), true);
break;
case KeyEvent.KEY_RELEASED:
pressed.remove(ke.getKeyCode());
break;
}
return false;
}
}
});
}
}
Вы можете использовать HashMap, чтобы проверить, нажата ли определенная клавиша, или вызвать KeyboardInput2.allPressed() печатать каждую нажатую клавишу.
Ну, вы сказали, что возможно, что время между ключевыми событиями в случае повторения ключа будет неотрицательным. Несмотря на это, это, вероятно, очень короткий. Затем вы можете ограничить это время до некоторого очень маленького значения, и все будет равным или меньшим, чем считается повторением ключа.
Что я не получаю от всех сложных, но сомнительных предложений? Решение очень простое! (Пропустил ключевую часть вопроса OP: "В Linux, когда пользователь держит какую-то клавишу, происходит много событий keyPress и keyRelease")
В вашем событии keyPress проверьте, есть ли код ключа в Set
Чтобы немного абстрагироваться, вы можете создать оболочку, которая может содержать KeyEvents, MouseEvents и MouseWheelEvents и имеет флаг, который уже говорит о том, что keyPress является просто автоповторением.