混淆按键事件之谜

huangapple
未分类评论63阅读模式
英文:

Case of the confounding key press caper

问题

  1. # 背景
  3. 为屏幕录制开发一个基本的、开源的键盘和鼠标在屏幕上显示的桌面应用程序，名为[KmCaster][1]：
  5. [![屏幕录制预览][2]][2]
  7. 该应用程序使用[JNativeHook][3]库来接收全局键盘和鼠标事件，因为Swing的[Key][4]和[Mouse][5]监听器只能接收针对应用程序本身的事件。
  9. # 问题
  11. 当应用程序失去焦点时，用户界面显示间歇性的按键操作，而不是每次按键操作。然而，控制台显示应用程序已接收到每次按键操作。
  13. # 代码
  15. 一个简短、自包含、可编译的示例：
  17. ```java
  18. import org.jnativehook.GlobalScreen;
  19. import org.jnativehook.NativeHookException;
  20. import org.jnativehook.keyboard.NativeKeyEvent;
  21. import org.jnativehook.keyboard.NativeKeyListener;
  23. import javax.swing.*;
  25. import static java.util.logging.Level.OFF;
  26. import static java.util.logging.Logger.getLogger;
  27. import static javax.swing.SwingUtilities.invokeLater;
  28. import static org.jnativehook.GlobalScreen.*;
  29. import static org.jnativehook.keyboard.NativeKeyEvent.getKeyText;
  31. public class Harness extends JFrame implements NativeKeyListener {
  33.   private final JLabel mLabel = new JLabel("Hello, world");
  34.   private int mCount;
  36.   public void init() {
  37.     getContentPane().add(mLabel);
  39.     setDefaultCloseOperation(EXIT_ON_CLOSE);
  40.     setLocationRelativeTo(null);
  41.     setAlwaysOnTop(true);
  42.     pack();
  43.     setVisible(true);
  44.   }
  46.   @Override
  47.   public void nativeKeyPressed(final NativeKeyEvent e) {
  48.     final var s = getKeyText(e.getKeyCode());
  49.     System.out.print(s + " " + (++mCount % 10 == 0 ? "\n" : ""));
  51.     invokeLater(() -> mLabel.setText(s));
  52.   }
  54.   public static void main(final String[] args) throws NativeHookException {
  55.     disableNativeHookLogger();
  56.     registerNativeHook();
  58.     final var harness = new Harness();
  59.     addNativeKeyListener(harness);
  61.     invokeLater(harness::init);
  62.   }
  64.   private static void disableNativeHookLogger() {
  65.     final var logger = getLogger(GlobalScreen.class.getPackage().getName());
  66.     logger.setLevel(OFF);
  67.     logger.setUseParentHandlers(false);
  68.   }
  70.   @Override
  71.   public void nativeKeyReleased(final NativeKeyEvent e) {}
  73.   @Override
  74.   public void nativeKeyTyped(final NativeKeyEvent e) {}
  75. }

上面的代码生成一个小窗口，在运行时演示了这个问题：

混淆按键事件之谜

确保在任何其他窗口中输入，以查看演示应用程序中令人困惑的按键丢失。

环境

  • OpenJDK版本 "14.0.1" 2020-04-14，64位
  • XFCE
  • Arch Linux
  • JNativeHook 2.1.0

细节

JNativeHook在它自己的线程中运行，但使用 invokeLater（或 invokeAndWait ？）应该在Swing的事件线程上发出UI更新。

对 disableNativeHookLogger() 的调用并不相关，它只是在运行演示时保持控制台清洁。

控制台输出

应用程序具有焦点时的控制台输出如下：

  1. Shift I Space A M Space I N S I 
  2. D E Space T H E Space A P P 
  3. L I C A T I O N Period

应用程序失去焦点时的控制台输出如下：

  1. Shift I Space A M Space O U T S
  2. I D E Space T H E Space A P
  3. P L I C A T I O N Period

因此，清楚地看到在调用 nativeKeyPressed 时不会丢失任何键盘事件，无论应用程序是否具有焦点。也就是说，无论是 JNativeHook 还是通过 JNI 进行的事件冒泡似乎都不是问题的根本原因。

问题

需要做出什么更改，以便在应用程序是否具有焦点的情况下，JLabel 的文本都会更新以显示每次按键操作？

想法

一些有帮助的想法包括：

  • 调用 getDefaultToolkit().sync(); 来显式刷新渲染管线。
  • 在标签上调用 paintImmediately(getBounds())。

第一项似乎有很大的差异，但仍然可能会丢失一些按键（尽管可能是因为我输入得太快）。阻止渲染管线合并绘制请求可以避免丢失按键是有道理的。

研究

与这个问题相关的资源：

  2. <details>
  3. <summary>英文:</summary>
  5. # Background
  7. Developing a rudimentary, open-source keyboard and mouse on-screen display desktop application for screen casting, called [KmCaster][1]:
  9. [![Screen Casting Preview][2]][2]
  11. The application uses the [JNativeHook][3] library to receive global keyboard and mouse events, because Swing&#39;s [Key][4] and [Mouse][5] listeners are restricted to receiving events directed at the application itself.
  13. # Problem
  15. When the application loses focus, the user interface shows intermittent key presses, rather than every key press. Yet the console shows that the application has received every key press.
  17. # Code
  19. A short, self-contained, compileable example:
  21. &lt;!-- language: java --&gt;
  23.     import org.jnativehook.GlobalScreen;
  24.     import org.jnativehook.NativeHookException;
  25.     import org.jnativehook.keyboard.NativeKeyEvent;
  26.     import org.jnativehook.keyboard.NativeKeyListener;
  27.     
  28.     import javax.swing.*;
  29.     
  30.     import static java.util.logging.Level.OFF;
  31.     import static java.util.logging.Logger.getLogger;
  32.     import static javax.swing.SwingUtilities.invokeLater;
  33.     import static org.jnativehook.GlobalScreen.*;
  34.     import static org.jnativehook.keyboard.NativeKeyEvent.getKeyText;
  36.     public class Harness extends JFrame implements NativeKeyListener {
  37.     
  38.       private final JLabel mLabel = new JLabel( &quot;Hello, world&quot; );
  39.       private int mCount;
  40.     
  41.       public void init() {
  42.         getContentPane().add( mLabel );
  43.     
  44.         setDefaultCloseOperation( EXIT_ON_CLOSE );
  45.         setLocationRelativeTo( null );
  46.         setAlwaysOnTop( true );
  47.         pack();
  48.         setVisible( true );
  49.       }
  50.     
  51.       @Override
  52.       public void nativeKeyPressed( final NativeKeyEvent e ) {
  53.         final var s = getKeyText( e.getKeyCode() );
  54.         System.out.print( s + &quot; &quot; + (++mCount % 10 == 0 ? &quot;\n&quot; : &quot;&quot;) );
  55.     
  56.         invokeLater( () -&gt; mLabel.setText( s ) );
  57.       }
  58.     
  59.       public static void main( final String[] args ) throws NativeHookException {
  60.         disableNativeHookLogger();
  61.         registerNativeHook();
  62.     
  63.         final var harness = new Harness();
  64.         addNativeKeyListener( harness );
  65.     
  66.         invokeLater( harness::init );
  67.       }
  68.     
  69.       private static void disableNativeHookLogger() {
  70.         final var logger = getLogger( GlobalScreen.class.getPackage().getName() );
  71.         logger.setLevel( OFF );
  72.         logger.setUseParentHandlers( false );
  73.       }
  75.       @Override
  76.       public void nativeKeyReleased( final NativeKeyEvent e ) {}
  77.     
  78.       @Override
  79.       public void nativeKeyTyped( final NativeKeyEvent e ) {}
  80.     }
  82. The code above produces a small window that, when run, demonstrates the problem:
  84. [![Harness Screenshot][6]][6]
  86. Be sure to type into any other window to see the perplexing loss of key presses within the demo application.
  88. # Environment
  90. * OpenJDK version &quot;14.0.1&quot; 2020-04-14, 64-bit
  91. * XFCE
  92. * Arch Linux
  93. * JNativeHook 2.1.0
  95. # Details
  97. JNativeHook runs in its own thread, but using `invokeLater` (or `invokeAndWait`?) should issue the UI update on Swing&#39;s event thread.
  99. The call to `disableNativeHookLogger()` isn&#39;t relevant, it merely keeps the console clean when running the demo.
  101. # Console Output
  103. Here is the console output when the application has focus:
  105. &lt;!-- language: plain --&gt;
  107.     Shift I Space A M Space I N S I 
  108.     D E Space T H E Space A P P 
  109.     L I C A T I O N Period
  111. Here is the console output when the application loses focus:
  113. &lt;!-- language: plain --&gt;
  115.     Shift I Space A M Space O U T S
  116.     I D E Space T H E Space A P
  117.     P L I C A T I O N Period 
  119. So it&#39;s clear that no keyboard events are missing when `nativeKeyPressed` is called, regardless of whether the application has focus. That is, neither JNativeHook nor its event bubbling via JNI appears to be the culprit.
  121. # Question
  123. What needs to change so that the `JLabel` text is updated for every key press regardless of whether the application has focus?
  125. # Ideas
  127. Some items that help include:
  129. * Call `getDefaultToolkit().sync();` to flush the rendering pipeline explicitly.
  130. * Call `paintImmediately( getBounds() )` on the label.
  132. The first item seems to make a huge difference, but some keys still appear to be missing (although it could be that I&#39;m typing too quickly). It makes sense that preventing the rendering pipeline from merging paint requests avoids loss of key strokes.
  134. # Research
  136. Resources related to this issue:
  138. * https://pavelfatin.com/low-latency-painting-in-awt-and-swing/
  140.   [1]: https://github.com/DaveJarvis/kmcaster
  141.   [2]: https://i.stack.imgur.com/wBDzs.png
  142.   [3]: https://github.com/kwhat/jnativehook/
  143.   [4]: https://docs.oracle.com/javase/9/docs/api/java/awt/event/KeyListener.html
  144.   [5]: https://docs.oracle.com/javase/9/docs/api/java/awt/event/MouseListener.html
  145.   [6]: https://i.stack.imgur.com/HiU3G.png
  147. </details>
  150. # 答案1
  151. **得分**: 1
  153. 使用默认工具包调用`sync()`：
  155. ```java
  156.       @Override
  157.       public void propertyChange( final PropertyChangeEvent e ) {
  158.         invokeLater(
  159.             () -> {
  160.               update( e );
  161.     
  162.               // 防止折叠多个绘图事件。
  163.               getDefaultToolkit().sync();
  164.             }
  165.         );
  166.       }

查看完整代码。

英文:

Call sync() using the default toolkit:

<!-- language: java -->

  1.   @Override
  2.   public void propertyChange( final PropertyChangeEvent e ) {
  3.     invokeLater(
  4.         () -&gt; {
  5.           update( e );
  7.           // Prevent collapsing multiple paint events.
  8.           getDefaultToolkit().sync();
  9.         }
  10.     );
  11.   }

See the full code.

huangapple
  • 本文由 发表于 2020年7月27日 07:44:56
  • 转载请务必保留本文链接：https://java.coder-hub.com/63106947.html
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定