issue with keyPressed and keyReleased

Newbie & Debugging Questions
#1

I have a class that implements the KeyListener interface. When I press a key down and release it after a couple of seconds, I would expect the keyPressed method to be invoked exactly once and the keyReleased method to be invoked exactly once.

But what happens is that both methods get invoked very often, although I do not release the key. Is there any way to prevent this and obtain the desired behaviour described above?

#2

IIRC, you can look at the time reported by InputEvent.getWhen(). The spurious pairs of KeyReleased and KeyPressed events will have the same event time, so you can safely ignore them.

#3

keyReleased should only be fired once anyway. keyPressed can be called multiple times due to the repeat rate set for the OS. that’s why if you hold a key down in a word processor, after a second or so it will repeat that key over and over. you could just keep an array of all keys states, and only treat keyPressed seriously when it changes the key state (i.e. changing it to the same state does nothing)

#4

It’s been a while since I’ve looked at this, but on linux this is not the case. You get a constant stream of keypressed/keyreleased pairs.

#5

really? that’s pretty messed up, I bet my games probably run wacky on linux systems! maybe the best way is to completely ignore keyReleased events, and only set a key state in your array to ‘released’ when you receive the keyTyped event?

#6

Yes, it’s really annoying :’(

This is what I do now:


public class Game implements KeyListener
{
	private class Keyvent
	{
		public KeyEvent _event;

		public boolean _pressed;

		public Keyvent(KeyEvent event, boolean pressed)
		{
			_event = event;
			_pressed = pressed;
		}
	}

	private Queue<Keyvent> _keyvents;

	public Game()
	{
		_keyvents = new LinkedList<Keyvent>();
	}

	public void keyPressed(KeyEvent e)
	{
		_keyvents.add(new Keyvent(e, true));
	}

	public void keyReleased(KeyEvent e)
	{
		_keyvents.add(new Keyvent(e, false));
	}

	public void update()
	{
		if (!_keyvents.isEmpty())
		{
			Iterator<Keyvent> it = _keyvents.iterator();
			Keyvent a = it.next();
			while (it.hasNext())
			{
				Keyvent b = it.next();
				if (a._event.getKeyCode() == b._event.getKeyCode()
						&& !a._pressed && b._pressed
						&& a._event.getWhen() == b._event.getWhen())
				{
					if (it.hasNext())
					{
						a = it.next();
					}
					else
					{
						a = null;
					}
				}
				else
				{
					processKeyvent(a);
					a = b;
				}
			}
			if (a != null)
			{
				processKeyvent(a);
			}
			_keyvents.clear();
		}
	}

	private void processKeyvent(Keyvent keyvent)
	{
		if (keyvent._pressed)
		{
			// do something with pressed key
		}
		else
		{
			// do something with released key
		}
	}
}

The problem is that update() does not run in the same thread as keyPressed and keyReleased. Sometimes update() gets invoked after the “fake” keyReleased has been put into the Queue, but the corresponding “fake” keyPressed has not yet been, and so the fake pair is not recognised as such.

Is there really no simple way such as a method like disableKeyRepeat() or something? :’(