Fixed how the minimum release time for keys work, and fixed a bug where a delayed release should not fire if the key is still down.

Author: lanceewing

core/src/main/java/emu/jvic/KeyboardMatrix.java

@@ -6,6 +6,7 @@
 import java.util.TreeMap;
 
 import com.badlogic.gdx.InputAdapter;
+import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.Input.Keys;
 import com.badlogic.gdx.utils.TimeUtils;
 
@@ -140,12 +141,12 @@ public abstract class KeyboardMatrix extends InputAdapter {
     private long minKeyReleaseTimes[] = new long[512];
 
     /**
-     * Holds a queue of keycodes whose key release processing has been delayed. This is
+     * Holds a map of keycodes whose key release processing has been delayed. This is
      * supported primarily for use with the Android virtual keyboard on some devices, 
      * where the key pressed and release both get fired on release of the key, so have
      * virtually no time between them.
      */
-    private TreeMap<Long, Integer> delayedReleaseKeys = new TreeMap<Long, Integer>();
+    private TreeMap<Integer, Long> delayedReleaseKeys = new TreeMap<Integer, Long>();
 
     /**
      * Maps keypress characters to VIC keys.
@@ -157,6 +158,11 @@ public abstract class KeyboardMatrix extends InputAdapter {
      */
     private HashMap<Integer, int[]> keycodeConvHashMap;
 
+    /**
+     * Maps VIC keys to libgdx keycodes.
+     */
+    private HashMap<Integer, Integer> vicKeyToLibgdxKeyMap;
+    
     /**
      * Constructor for KeyboardMatrix.
      */
@@ -185,6 +191,14 @@ public KeyboardMatrix() {
             System.arraycopy(vicKeyMapping, 1, vicKeys, 0, vicKeyMapping.length-1);
             keycodeConvHashMap.put(vicKeyMapping[0], vicKeys);
         }
+        
+        // Converts VIC key to libgdx keycode.
+        vicKeyToLibgdxKeyMap = new HashMap<Integer, Integer>();
+        for (int i=0; i < VicKeys.VIC_KEY_TO_LIBGDX_KEY_MAP.length; i++) {
+            vicKeyToLibgdxKeyMap.put(
+                    VicKeys.VIC_KEY_TO_LIBGDX_KEY_MAP[i][0], 
+                    VicKeys.VIC_KEY_TO_LIBGDX_KEY_MAP[i][1]);
+        }
     }
 
     public boolean keyDown(int keycode) {
@@ -261,7 +275,7 @@ public void vicKeyUp(int vicKey) {
                 // keyboard or something similar that doesn't reflect the actual time the key 
                 // is down), so let's add this keycode to the delayed release list.
                 synchronized(delayedReleaseKeys) {
-                    delayedReleaseKeys.put(minKeyReleaseTime, vicKey);
+                    delayedReleaseKeys.put(vicKey, minKeyReleaseTime);
                 }
 
             } else {
@@ -344,13 +358,45 @@ public boolean isAltKeyDown() {
     public void checkDelayedReleaseKeys() {
         if (!delayedReleaseKeys.isEmpty()) {
             synchronized (delayedReleaseKeys) {
-                List<Long> processedReleases = new ArrayList<Long>();
-                processedReleases.addAll(delayedReleaseKeys.headMap(TimeUtils.nanoTime()).keySet());
-                for (Long keyReleaseTime : processedReleases) {
-                    int delayedReleaseVicKey = delayedReleaseKeys.remove(keyReleaseTime);
-                    vicKeyUp(delayedReleaseVicKey);
+                // Identify the keys whose minimum release time has based.
+                long currentTime = TimeUtils.nanoTime();
+                List<Integer> releasesToProcess = new ArrayList<Integer>();
+                for (Integer vicKey : delayedReleaseKeys.keySet()) {
+                    if (currentTime >= delayedReleaseKeys.get(vicKey)) {
+                        releasesToProcess.add(vicKey);
+                    }
                 }
+                
+                // Now process the key releases.
+                for (Integer delayedReleaseVicKey : releasesToProcess) {
+                    // Only trigger vicKeyUp if the key is not still down.
+                    if (!isKeyCurrentlyDown(delayedReleaseVicKey)) {
+                        vicKeyUp(delayedReleaseVicKey);
+                        delayedReleaseKeys.remove(delayedReleaseVicKey);
+                    } else {
+                        // Key is still down.
+                    }
+                }
+            }
+        }
+    }
+    
+    /**
+     * Checks if the given VIC key is down.
+     * 
+     * @param vicKey The VIC key to check.
+     * 
+     * @return true if the VIC key is down; otherwise false.
+     */
+    public boolean isKeyCurrentlyDown(int vicKey) {
+        if (vicKey != 0) {
+            if (vicKeyToLibgdxKeyMap.containsKey(vicKey)) {
+                return Gdx.input.isKeyPressed(vicKeyToLibgdxKeyMap.get(vicKey));
+            } else {
+                return false;
             }
+        } else {
+            return false;
         }
     }
 

core/src/main/java/emu/jvic/VicKeys.java

@@ -254,4 +254,64 @@ public interface VicKeys {
         { Keys.NUMPAD_8, VicKeys.JOYSTICK_UP },  // Up
         { Keys.NUMPAD_9, VicKeys.JOYSTICK_NE },  // NE
     };
+    
+    public static final int[][] VIC_KEY_TO_LIBGDX_KEY_MAP = new int[][] {
+        { VicKeys.ONE, Keys.NUM_1 },
+        { VicKeys.TWO, Keys.NUM_2 },
+        { VicKeys.THREE, Keys.NUM_3 },
+        { VicKeys.FOUR, Keys.NUM_4 },
+        { VicKeys.FIVE, Keys.NUM_5 },
+        { VicKeys.SIX, Keys.NUM_6 },
+        { VicKeys.SEVEN, Keys.NUM_7 },
+        { VicKeys.EIGHT, Keys.NUM_8 },
+        { VicKeys.NINE, Keys.NUM_9 },
+        { VicKeys.ZERO, Keys.NUM_0 },
+        { VicKeys.HYPHEN, Keys.MINUS },
+        { VicKeys.EQUALS, Keys.EQUALS },
+        { VicKeys.HOME, Keys.HOME },
+        { VicKeys.DELETE, Keys.BACKSPACE },
+        { VicKeys.CONTROL, Keys.CONTROL_LEFT },
+        { VicKeys.CBM, Keys.TAB },
+        { VicKeys.Q, Keys.Q },
+        { VicKeys.W, Keys.W },
+        { VicKeys.E, Keys.E },
+        { VicKeys.R, Keys.R },
+        { VicKeys.T, Keys.T },
+        { VicKeys.Y, Keys.Y },
+        { VicKeys.U, Keys.U },
+        { VicKeys.I, Keys.I },
+        { VicKeys.P, Keys.P },
+        { VicKeys.A, Keys.A },
+        { VicKeys.S, Keys.S },
+        { VicKeys.D, Keys.D },
+        { VicKeys.F, Keys.F },
+        { VicKeys.G, Keys.G },
+        { VicKeys.H, Keys.H },
+        { VicKeys.J, Keys.J },
+        { VicKeys.K, Keys.K },
+        { VicKeys.L, Keys.L },
+        { VicKeys.SEMI_COLON, Keys.SEMICOLON },
+        { VicKeys.COLON, Keys.COLON },
+        { VicKeys.RETURN, Keys.ENTER },
+        { VicKeys.LEFT_SHIFT, Keys.SHIFT_LEFT },
+        { VicKeys.Z, Keys.Z },
+        { VicKeys.X, Keys.X },
+        { VicKeys.C, Keys.C },
+        { VicKeys.V, Keys.V },
+        { VicKeys.B, Keys.B },
+        { VicKeys.N, Keys.N },
+        { VicKeys.M, Keys.M },
+        { VicKeys.COMMA, Keys.COMMA },
+        { VicKeys.PERIOD, Keys.PERIOD },
+        { VicKeys.FORWARD_SLASH, Keys.SLASH },
+        { VicKeys.RIGHT_SHIFT, Keys.SHIFT_RIGHT },
+        { VicKeys.CURSOR_DOWN, Keys.DOWN },
+        { VicKeys.CURSOR_RIGHT, Keys.RIGHT },
+        { VicKeys.SPACE, Keys.SPACE },
+        { VicKeys.F1, Keys.F1 },
+        { VicKeys.F3, Keys.F3 },
+        { VicKeys.F5, Keys.F5 },
+        { VicKeys.F7, Keys.F7 },
+        { VicKeys.SHIFT_LOCK, Keys.CAPS_LOCK }
+    };
 }