metodos - keyevent java docs

Convertir cadena en KeyEvents

Question

Quiero convertir un String en KeyEvent para hacer algo como esto:

writeKeyboard(myBot,"abcd");
public void writeKeyboard(Robot bot, String st){
char[] arr = arr.toCharArray();
int i = arr.length();
int j = 0;
int keycode;
while (j<i) {
keycode = arr[j].something;
bot.keyPress(keycode);
bot.keyRelease(keycode);
j++;
}
}

Answer 1

Así es como logré usar todas las claves disponibles. Crea un Mapa y llena el mapa usando el método fillKeyMap. Ahora puede usar la representación de cadena de eventos clave y convertirla de nuevo en códigos KeyEvent usando el mapa.

/** Create map with string values to integer pairs
*/
public static final void fillKeyMap(Map<String, Integer> into) {
try {
Field[] fields = KeyEvent.class.getDeclaredFields();
for(Field f : fields) {
if(f.getName().startsWith("VK_")) { //we only want these fields
int code = ((Integer)f.get(null)).intValue();
into.put(f.getName().substring(3), code);
}
}
} catch(Exception ex) {}
}

Answer 2

Básicamente estoy usando el patrón Command como lo hace Rich Seller en su respuesta, con dos modificaciones menores por el bien de la brevedad:

• uso del patrón de Decoración para reutilizar instancias de comando az
• uso de reflexión para eliminar KeyEvent.VK _ ???

Interfaz de comando:

interface Command {
void pressKey(Robot robot);
}

y el decorador (para la modificación n. ° 1):

class ShiftCommand implements Command {
private final Command command;
public ShiftCommand(Command command) {
this.command = command;
}
public void pressKey(Robot robot) {
robot.keyPress(KeyEvent.VK_SHIFT);
command.pressKey(robot);
robot.keyRelease(KeyEvent.VK_SHIFT);
}
@Override
public String toString() {
return "SHIFT + " + command.toString();
}
}

usando esta ayuda (para la modificación n. ° 2):

public static int getKeyEvent(Character c) {
Field f = KeyEvent.class.getField("VK_" + Character.toUpperCase(c));
f.setAccessible(true);
return (Integer) f.get(null);
}

CUIDADO : No estoy manejando excepciones aquí, esto se deja como ejercicio para ti :))

luego completando el comando usando un ciclo for:

Map<Character, Command> commandMap = new HashMap<Character, Command>();
for (int i = ''a''; i <= ''z''; i++) {
final Character c = Character.valueOf((char) i);
Command pressKeyCommand = new Command() {
public void pressKey(Robot robot) {
int keyEventCode = getKeyEvent(c);
robot.keyPress(c);
robot.keyRelease(c);
}
@Override
public String toString() {
return String.format("%c", c);
}
};
// ''a'' .. ''z''
commandMap.put(c, pressKeyCommand);
// ''A'' .. ''Z'' by decorating pressKeyCommand
commandMap.put(Character.toUpperCase(c), new ShiftCommand(pressKeyCommand));
}

Caso de prueba

String test = "aaaBBB";
for (int i = 0; i < test.length(); i++) {
System.out.println(commandMap.get(test.charAt(i)));
}

como se esperaba, esta producción:

a a a SHIFT + b SHIFT + b SHIFT + b

Answer 3

Básicamente estoy usando una declaración de switch glorificado. Simple y rápido:

import static java.awt.event.KeyEvent.*;
public class Keyboard {
private Robot robot;
public static void main(String... args) throws Exception {
Keyboard keyboard = new Keyboard();
keyboard.type("Hello there, how are you?");
}
public Keyboard() throws AWTException {
this.robot = new Robot();
}
public Keyboard(Robot robot) {
this.robot = robot;
}
public void type(CharSequence characters) {
int length = characters.length();
for (int i = 0; i < length; i++) {
char character = characters.charAt(i);
type(character);
}
}
public void type(char character) {
switch (character) {
case ''a'': doType(VK_A); break;
case ''b'': doType(VK_B); break;
case ''c'': doType(VK_C); break;
case ''d'': doType(VK_D); break;
case ''e'': doType(VK_E); break;
case ''f'': doType(VK_F); break;
case ''g'': doType(VK_G); break;
case ''h'': doType(VK_H); break;
case ''i'': doType(VK_I); break;
case ''j'': doType(VK_J); break;
case ''k'': doType(VK_K); break;
case ''l'': doType(VK_L); break;
case ''m'': doType(VK_M); break;
case ''n'': doType(VK_N); break;
case ''o'': doType(VK_O); break;
case ''p'': doType(VK_P); break;
case ''q'': doType(VK_Q); break;
case ''r'': doType(VK_R); break;
case ''s'': doType(VK_S); break;
case ''t'': doType(VK_T); break;
case ''u'': doType(VK_U); break;
case ''v'': doType(VK_V); break;
case ''w'': doType(VK_W); break;
case ''x'': doType(VK_X); break;
case ''y'': doType(VK_Y); break;
case ''z'': doType(VK_Z); break;
case ''A'': doType(VK_SHIFT, VK_A); break;
case ''B'': doType(VK_SHIFT, VK_B); break;
case ''C'': doType(VK_SHIFT, VK_C); break;
case ''D'': doType(VK_SHIFT, VK_D); break;
case ''E'': doType(VK_SHIFT, VK_E); break;
case ''F'': doType(VK_SHIFT, VK_F); break;
case ''G'': doType(VK_SHIFT, VK_G); break;
case ''H'': doType(VK_SHIFT, VK_H); break;
case ''I'': doType(VK_SHIFT, VK_I); break;
case ''J'': doType(VK_SHIFT, VK_J); break;
case ''K'': doType(VK_SHIFT, VK_K); break;
case ''L'': doType(VK_SHIFT, VK_L); break;
case ''M'': doType(VK_SHIFT, VK_M); break;
case ''N'': doType(VK_SHIFT, VK_N); break;
case ''O'': doType(VK_SHIFT, VK_O); break;
case ''P'': doType(VK_SHIFT, VK_P); break;
case ''Q'': doType(VK_SHIFT, VK_Q); break;
case ''R'': doType(VK_SHIFT, VK_R); break;
case ''S'': doType(VK_SHIFT, VK_S); break;
case ''T'': doType(VK_SHIFT, VK_T); break;
case ''U'': doType(VK_SHIFT, VK_U); break;
case ''V'': doType(VK_SHIFT, VK_V); break;
case ''W'': doType(VK_SHIFT, VK_W); break;
case ''X'': doType(VK_SHIFT, VK_X); break;
case ''Y'': doType(VK_SHIFT, VK_Y); break;
case ''Z'': doType(VK_SHIFT, VK_Z); break;
case ''`'': doType(VK_BACK_QUOTE); break;
case ''0'': doType(VK_0); break;
case ''1'': doType(VK_1); break;
case ''2'': doType(VK_2); break;
case ''3'': doType(VK_3); break;
case ''4'': doType(VK_4); break;
case ''5'': doType(VK_5); break;
case ''6'': doType(VK_6); break;
case ''7'': doType(VK_7); break;
case ''8'': doType(VK_8); break;
case ''9'': doType(VK_9); break;
case ''-'': doType(VK_MINUS); break;
case ''='': doType(VK_EQUALS); break;
case ''~'': doType(VK_SHIFT, VK_BACK_QUOTE); break;
case ''!'': doType(VK_EXCLAMATION_MARK); break;
case ''@'': doType(VK_AT); break;
case ''#'': doType(VK_NUMBER_SIGN); break;
case ''$'': doType(VK_DOLLAR); break;
case ''%'': doType(VK_SHIFT, VK_5); break;
case ''^'': doType(VK_CIRCUMFLEX); break;
case ''&'': doType(VK_AMPERSAND); break;
case ''*'': doType(VK_ASTERISK); break;
case ''('': doType(VK_LEFT_PARENTHESIS); break;
case '')'': doType(VK_RIGHT_PARENTHESIS); break;
case ''_'': doType(VK_UNDERSCORE); break;
case ''+'': doType(VK_PLUS); break;
case ''/t'': doType(VK_TAB); break;
case ''/n'': doType(VK_ENTER); break;
case ''['': doType(VK_OPEN_BRACKET); break;
case '']'': doType(VK_CLOSE_BRACKET); break;
case ''//': doType(VK_BACK_SLASH); break;
case ''{'': doType(VK_SHIFT, VK_OPEN_BRACKET); break;
case ''}'': doType(VK_SHIFT, VK_CLOSE_BRACKET); break;
case ''|'': doType(VK_SHIFT, VK_BACK_SLASH); break;
case '';'': doType(VK_SEMICOLON); break;
case '':'': doType(VK_COLON); break;
case ''/''': doType(VK_QUOTE); break;
case ''"'': doType(VK_QUOTEDBL); break;
case '','': doType(VK_COMMA); break;
case ''<'': doType(VK_SHIFT, VK_COMMA); break;
case ''.'': doType(VK_PERIOD); break;
case ''>'': doType(VK_SHIFT, VK_PERIOD); break;
case ''/'': doType(VK_SLASH); break;
case ''?'': doType(VK_SHIFT, VK_SLASH); break;
case '' '': doType(VK_SPACE); break;
default:
throw new IllegalArgumentException("Cannot type character " + character);
}
}
private void doType(int... keyCodes) {
doType(keyCodes, 0, keyCodes.length);
}
private void doType(int[] keyCodes, int offset, int length) {
if (length == 0) {
return;
}
robot.keyPress(keyCodes[offset]);
doType(keyCodes, offset + 1, length - 1);
robot.keyRelease(keyCodes[offset]);
}
}

Si desea escribir algunas teclas personalizadas, puede extender la clase y anular el método de type(char) . Por ejemplo:

import static java.awt.event.KeyEvent.*;
public class WindowUnicodeKeyboard extends Keyboard {
private Robot robot;
public WindowUnicodeKeyboard(Robot robot) {
super(robot);
this.robot = robot;
}
@Override
public void type(char character) {
try {
super.type(character);
} catch (IllegalArgumentException e) {
String unicodeDigits = String.valueOf(Character.getCodePoint(character));
robot.keyPress(VK_ALT);
for (int i = 0; i < unicodeDigits.length(); i++) {
typeNumPad(Integer.parseInt(unicodeDigits.substring(i, i + 1)));
}
robot.keyRelease(VK_ALT);
}
}
private void typeNumPad(int digit) {
switch (digit) {
case 0: doType(VK_NUMPAD0); break;
case 1: doType(VK_NUMPAD1); break;
case 2: doType(VK_NUMPAD2); break;
case 3: doType(VK_NUMPAD3); break;
case 4: doType(VK_NUMPAD4); break;
case 5: doType(VK_NUMPAD5); break;
case 6: doType(VK_NUMPAD6); break;
case 7: doType(VK_NUMPAD7); break;
case 8: doType(VK_NUMPAD8); break;
case 9: doType(VK_NUMPAD9); break;
}
}
}

Por supuesto, hay margen de mejora, pero entiendes la idea.

Answer 4

Descubrí que combinar las respuestas de Ryan Hilbert y Adam Paynter me dio el mejor resultado. Combina la velocidad de las teclas individuales con la robustez de los códigos alt. El código combinado:

/**
* Created by Daniel on 25/8/2016.
*/
import java.awt.AWTException;
import java.awt.Robot;
import static java.awt.event.KeyEvent.VK_0;
import static java.awt.event.KeyEvent.VK_1;
import static java.awt.event.KeyEvent.VK_2;
import static java.awt.event.KeyEvent.VK_3;
import static java.awt.event.KeyEvent.VK_4;
import static java.awt.event.KeyEvent.VK_5;
import static java.awt.event.KeyEvent.VK_6;
import static java.awt.event.KeyEvent.VK_7;
import static java.awt.event.KeyEvent.VK_8;
import static java.awt.event.KeyEvent.VK_9;
import static java.awt.event.KeyEvent.VK_A;
import static java.awt.event.KeyEvent.VK_ALT;
import static java.awt.event.KeyEvent.VK_B;
import static java.awt.event.KeyEvent.VK_BACK_QUOTE;
import static java.awt.event.KeyEvent.VK_BACK_SLASH;
import static java.awt.event.KeyEvent.VK_C;
import static java.awt.event.KeyEvent.VK_CLOSE_BRACKET;
import static java.awt.event.KeyEvent.VK_COLON;
import static java.awt.event.KeyEvent.VK_COMMA;
import static java.awt.event.KeyEvent.VK_D;
import static java.awt.event.KeyEvent.VK_E;
import static java.awt.event.KeyEvent.VK_ENTER;
import static java.awt.event.KeyEvent.VK_EQUALS;
import static java.awt.event.KeyEvent.VK_F;
import static java.awt.event.KeyEvent.VK_G;
import static java.awt.event.KeyEvent.VK_H;
import static java.awt.event.KeyEvent.VK_I;
import static java.awt.event.KeyEvent.VK_J;
import static java.awt.event.KeyEvent.VK_K;
import static java.awt.event.KeyEvent.VK_L;
import static java.awt.event.KeyEvent.VK_M;
import static java.awt.event.KeyEvent.VK_MINUS;
import static java.awt.event.KeyEvent.VK_N;
import static java.awt.event.KeyEvent.VK_NUMPAD0;
import static java.awt.event.KeyEvent.VK_O;
import static java.awt.event.KeyEvent.VK_OPEN_BRACKET;
import static java.awt.event.KeyEvent.VK_P;
import static java.awt.event.KeyEvent.VK_PERIOD;
import static java.awt.event.KeyEvent.VK_Q;
import static java.awt.event.KeyEvent.VK_QUOTE;
import static java.awt.event.KeyEvent.VK_QUOTEDBL;
import static java.awt.event.KeyEvent.VK_R;
import static java.awt.event.KeyEvent.VK_S;
import static java.awt.event.KeyEvent.VK_SEMICOLON;
import static java.awt.event.KeyEvent.VK_SHIFT;
import static java.awt.event.KeyEvent.VK_SLASH;
import static java.awt.event.KeyEvent.VK_SPACE;
import static java.awt.event.KeyEvent.VK_T;
import static java.awt.event.KeyEvent.VK_TAB;
import static java.awt.event.KeyEvent.VK_U;
import static java.awt.event.KeyEvent.VK_V;
import static java.awt.event.KeyEvent.VK_W;
import static java.awt.event.KeyEvent.VK_X;
import static java.awt.event.KeyEvent.VK_Y;
import static java.awt.event.KeyEvent.VK_Z;
public class Keyboard { // http://.com/a/1248709/4330555
private Robot robot;
public Keyboard() throws AWTException {
this.robot = new Robot();
}
public Keyboard(Robot robot) {
this.robot = robot;
}
public void type(CharSequence characters) {
int length = characters.length();
for (int i = 0; i < length; i++) {
char character = characters.charAt(i);
try {
type(character);
} catch (IllegalArgumentException e) {
robot.keyPress(VK_ALT);
robot.keyPress(VK_NUMPAD0);
robot.keyRelease(VK_NUMPAD0);
String altCode = Integer.toString(character);
for (int j = 0; j < altCode.length(); j++) {
char c = (char) (altCode.charAt(j) + ''0'');
robot.keyPress(c);
robot.keyRelease(c);
}
robot.keyRelease(VK_ALT);
}
}
}
public void type(char character) {
switch (character) {
case ''a'':
doType(VK_A);
break;
case ''b'':
doType(VK_B);
break;
case ''c'':
doType(VK_C);
break;
case ''d'':
doType(VK_D);
break;
case ''e'':
doType(VK_E);
break;
case ''f'':
doType(VK_F);
break;
case ''g'':
doType(VK_G);
break;
case ''h'':
doType(VK_H);
break;
case ''i'':
doType(VK_I);
break;
case ''j'':
doType(VK_J);
break;
case ''k'':
doType(VK_K);
break;
case ''l'':
doType(VK_L);
break;
case ''m'':
doType(VK_M);
break;
case ''n'':
doType(VK_N);
break;
case ''o'':
doType(VK_O);
break;
case ''p'':
doType(VK_P);
break;
case ''q'':
doType(VK_Q);
break;
case ''r'':
doType(VK_R);
break;
case ''s'':
doType(VK_S);
break;
case ''t'':
doType(VK_T);
break;
case ''u'':
doType(VK_U);
break;
case ''v'':
doType(VK_V);
break;
case ''w'':
doType(VK_W);
break;
case ''x'':
doType(VK_X);
break;
case ''y'':
doType(VK_Y);
break;
case ''z'':
doType(VK_Z);
break;
case ''A'':
doType(VK_SHIFT, VK_A);
break;
case ''B'':
doType(VK_SHIFT, VK_B);
break;
case ''C'':
doType(VK_SHIFT, VK_C);
break;
case ''D'':
doType(VK_SHIFT, VK_D);
break;
case ''E'':
doType(VK_SHIFT, VK_E);
break;
case ''F'':
doType(VK_SHIFT, VK_F);
break;
case ''G'':
doType(VK_SHIFT, VK_G);
break;
case ''H'':
doType(VK_SHIFT, VK_H);
break;
case ''I'':
doType(VK_SHIFT, VK_I);
break;
case ''J'':
doType(VK_SHIFT, VK_J);
break;
case ''K'':
doType(VK_SHIFT, VK_K);
break;
case ''L'':
doType(VK_SHIFT, VK_L);
break;
case ''M'':
doType(VK_SHIFT, VK_M);
break;
case ''N'':
doType(VK_SHIFT, VK_N);
break;
case ''O'':
doType(VK_SHIFT, VK_O);
break;
case ''P'':
doType(VK_SHIFT, VK_P);
break;
case ''Q'':
doType(VK_SHIFT, VK_Q);
break;
case ''R'':
doType(VK_SHIFT, VK_R);
break;
case ''S'':
doType(VK_SHIFT, VK_S);
break;
case ''T'':
doType(VK_SHIFT, VK_T);
break;
case ''U'':
doType(VK_SHIFT, VK_U);
break;
case ''V'':
doType(VK_SHIFT, VK_V);
break;
case ''W'':
doType(VK_SHIFT, VK_W);
break;
case ''X'':
doType(VK_SHIFT, VK_X);
break;
case ''Y'':
doType(VK_SHIFT, VK_Y);
break;
case ''Z'':
doType(VK_SHIFT, VK_Z);
break;
case ''`'':
doType(VK_BACK_QUOTE);
break;
case ''0'':
doType(VK_0);
break;
case ''1'':
doType(VK_1);
break;
case ''2'':
doType(VK_2);
break;
case ''3'':
doType(VK_3);
break;
case ''4'':
doType(VK_4);
break;
case ''5'':
doType(VK_5);
break;
case ''6'':
doType(VK_6);
break;
case ''7'':
doType(VK_7);
break;
case ''8'':
doType(VK_8);
break;
case ''9'':
doType(VK_9);
break;
case ''-'':
doType(VK_MINUS);
break;
case ''='':
doType(VK_EQUALS);
break;
case ''~'':
doType(VK_SHIFT, VK_BACK_QUOTE);
break;
case ''!'':
doType(VK_SHIFT, VK_1);
break;
case ''@'':
doType(VK_SHIFT, VK_2);
break;
case ''#'':
doType(VK_SHIFT, VK_3);
break;
case ''$'':
doType(VK_SHIFT, VK_4);
break;
case ''%'':
doType(VK_SHIFT, VK_5);
break;
case ''^'':
doType(VK_SHIFT, VK_6);
break;
case ''&'':
doType(VK_SHIFT, VK_7);
break;
case ''*'':
doType(VK_SHIFT, VK_8);
break;
case ''('':
doType(VK_SHIFT, VK_9);
break;
case '')'':
doType(VK_SHIFT, VK_0);
break;
case ''_'':
doType(VK_SHIFT, VK_MINUS);
break;
case ''+'':
doType(VK_SHIFT, VK_EQUALS);
break;
case ''/t'':
doType(VK_TAB);
break;
case ''/n'':
doType(VK_ENTER);
break;
case ''['':
doType(VK_OPEN_BRACKET);
break;
case '']'':
doType(VK_CLOSE_BRACKET);
break;
case ''//':
doType(VK_BACK_SLASH);
break;
case ''{'':
doType(VK_SHIFT, VK_OPEN_BRACKET);
break;
case ''}'':
doType(VK_SHIFT, VK_CLOSE_BRACKET);
break;
case ''|'':
doType(VK_SHIFT, VK_BACK_SLASH);
break;
case '';'':
doType(VK_SEMICOLON);
break;
case '':'':
doType(VK_COLON);
break;
case ''/''':
doType(VK_QUOTE);
break;
case ''"'':
doType(VK_QUOTEDBL);
break;
case '','':
doType(VK_COMMA);
break;
case ''<'':
doType(VK_SHIFT, VK_COMMA);
break;
case ''.'':
doType(VK_PERIOD);
break;
case ''>'':
doType(VK_SHIFT, VK_PERIOD);
break;
case ''/'':
doType(VK_SLASH);
break;
case ''?'':
doType(VK_SHIFT, VK_SLASH);
break;
case '' '':
doType(VK_SPACE);
break;
default:
throw new IllegalArgumentException("Cannot type character " + character);
}
}
private void doType(int... keyCodes) {
doType(keyCodes, 0, keyCodes.length);
}
private void doType(int[] keyCodes, int offset, int length) {
if (length == 0) {
return;
}
robot.keyPress(keyCodes[offset]);
doType(keyCodes, offset + 1, length - 1);
robot.keyRelease(keyCodes[offset]);
}
}

Answer 5

Desearía tener 50 puntos de reputación para comentar sobre la solución de Adam Paynter , pero aún no ...

Su clase de Keyboard funcionó bien, pero tuve problemas con las claves que no son alfabéticas, como : / y / .

La solución que encontré fue presionar y mantener presionado <ALT> mientras se <ALT> el <ASCII code> de dichas teclas.

Antes que nada, cambié el método doType() para mantener presionadas solo SHIFT y / o ALT , pero no todas las claves que componen el código ASCII. Bastante, así es como los humanos usan los teclados :)

private void doType(int[] keyCodes, int offset, int length) {
if (length == 0) {
return;
}
robot.keyPress(keyCodes[offset]);
if (keyCodes[offset] == KeyEvent.VK_ALT
|| keyCodes[offset] == KeyEvent.VK_SHIFT) {
doType(keyCodes, offset + 1, length - 1);
robot.keyRelease(keyCodes[offset]);
} else {
robot.keyRelease(keyCodes[offset]);
doType(keyCodes, offset + 1, length - 1);
}
}

Luego, cambié la caja del interruptor para pasar ALT y el código ASCII:

 case ''//' :
doType(KeyEvent.VK_ALT, KeyEvent.VK_NUMPAD9,
KeyEvent.VK_NUMPAD2);
case '':'' :
doType(KeyEvent.VK_ALT, KeyEvent.VK_NUMPAD5,
KeyEvent.VK_NUMPAD8);
case ''/'' :
doType(KeyEvent.VK_ALT, KeyEvent.VK_NUMPAD4,
KeyEvent.VK_NUMPAD7);

=============================================== ===== ADICIÓN

Modifiqué esta clase un poco más:

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Keyboard {
private static final Logger LOG = LoggerFactory.getLogger(Utils.class);
private Robot robot;
public Keyboard() {
try {
this.robot = new Robot();
} catch (AWTException e) {
LOG.error("Unable to create Robot object", e);
throw new RuntimeException(e);
}
}
public void type(String text) {
char c;
for (int ii = 0; ii < text.length(); ii++) {
c = text.charAt(ii);
if (c <= 31 || c == 129) {
pressControlKey(c);
} else {
typeAsciiCode(c);
}
}
}
private void pressControlKey(char c) {
robot.keyPress(c);
robot.keyRelease(c);
}
private void typeAsciiCode(char c) {
robot.keyPress(KeyEvent.VK_ALT);
String asciiCode = Integer.toString(c);
for (int i = 0; i < asciiCode.length(); i++) {
c = (char) (asciiCode.charAt(i) + ''0'');
robot.keyPress(c);
robot.keyRelease(c);
}
robot.keyRelease(KeyEvent.VK_ALT);
}
}

Answer 6

Es un poco Kludge, pero puede usar el patrón Command para encapsular las pulsaciones de teclado para cada carácter en la Cadena, luego obtener el Comando para cada personaje e invocar el método. La ventaja de esto es que solo tiene que configurar el mapa una vez. La desventaja es que todavía implica un montón de bolierplate:

public interface Command {
void pressKey(Robot bot);
}
//add a command to the map for each keystroke
commandMap.put("A", new Command() {
void pressKey(Robot bot) {
pressWithShift(KeyEvent.VK_A);
}
});
commandMap.put ("a", new Command() {
void pressKey (Robot bot) {
press (KeyEvent.VK_A);
}
});
commandMap.put("B", new Command() {
void pressKey(Robot bot) {
pressWithShift(KeyEvent.VK_B);
}
});
...
//loads more definitions here
//helper methods
private void pressWithShift (Robot bot, KeyEvent event) {
bot.keyPress (KeyEvent.VK_SHIFT);
press(bot, event);
bot.keyRelase(KeyEvent.VK_SHIFT);
}
private void press(Robot bot, KeyEvent event) {
bot.keyPress(event);
bot.keyRelease(event);
}

Entonces para usar el Mapa:

for (int i = 0; i < st.length(); i++) {
String subString = st.substring(i, i + 1);
commandMap.get(subString).pressKey(bot);
}

Answer 7

La respuesta aceptada me parece muy hinchada. Aquí hay una solución un poco más concisa que está basada en la respuesta aceptada. Debe manejar casi cualquier caso de uso. También maneja /n (nueva línea), /t (pestaña) y /b (retroceso), como se muestra en el ejemplo.

import java.awt.AWTException;
import java.awt.AWTKeyStroke;
import static java.awt.AWTKeyStroke.getAWTKeyStroke;
import java.awt.Robot;
import static java.awt.event.InputEvent.SHIFT_DOWN_MASK;
import java.awt.event.KeyEvent;
public class Keyboard {
private final Robot robot;
public Keyboard() throws AWTException {
this.robot = new Robot();
}
public static void main(String[] args) throws Exception {
Runtime.getRuntime().exec("notepad.exe");
Thread.sleep(3000L);
Keyboard keyboard = new Keyboard();
keyboard.type("`1234567890-=[]//;'',.//n");
keyboard.type("~!@#$%^&*()_+{}|:/"<>?/n");
keyboard.type("abcdefghijklmnopqrstuvwxyz/n/tABCDEFGHIJKLMNOPQRSTUVWXYZ");
keyboard.type("/n/n/twh/bat");
}
private static AWTKeyStroke getKeyStroke(char c) {
String upper = "`~''/"!@#$%^&*()_+{}|:<>?";
String lower = "`~''/"1234567890-=[]//;,./";
int index = upper.indexOf(c);
if (index != -1) {
int keyCode;
boolean shift = false;
switch (c) {
// these chars need to be handled specially because
// they don''t directly translate into the correct keycode
case ''~'':
shift = true;
case ''`'':
keyCode = KeyEvent.VK_BACK_QUOTE;
break;
case ''/"'':
shift = true;
case ''/''':
keyCode = KeyEvent.VK_QUOTE;
break;
default:
keyCode = (int) Character.toUpperCase(lower.charAt(index));
shift = true;
}
return getAWTKeyStroke(keyCode, shift ? SHIFT_DOWN_MASK : 0);
}
return getAWTKeyStroke((int) Character.toUpperCase(c), 0);
}
public void type(CharSequence chars) {
type(chars, 0);
}
public void type(CharSequence chars, int ms) {
ms = ms > 0 ? ms : 0;
for (int i = 0, len = chars.length(); i < len; i++) {
char c = chars.charAt(i);
AWTKeyStroke keyStroke = getKeyStroke(c);
int keyCode = keyStroke.getKeyCode();
boolean shift = Character.isUpperCase(c) || keyStroke.getModifiers() == (SHIFT_DOWN_MASK + 1);
if (shift) {
robot.keyPress(KeyEvent.VK_SHIFT);
}
robot.keyPress(keyCode);
robot.keyRelease(keyCode);
if (shift) {
robot.keyRelease(KeyEvent.VK_SHIFT);
}
if (ms > 0) {
robot.delay(ms);
}
}
}
}

Answer 8

Leve modificación a la respuesta de Adam Paynter porque el código no funcionaba para todas las teclas, por ejemplo,!, @, #, $ Etc. (Necesario para presionar VK_SHIFT primero)

public void type(char character) {
switch (character) {
case ''a'': doType(VK_A); break;
case ''b'': doType(VK_B); break;
case ''c'': doType(VK_C); break;
case ''d'': doType(VK_D); break;
case ''e'': doType(VK_E); break;
case ''f'': doType(VK_F); break;
case ''g'': doType(VK_G); break;
case ''h'': doType(VK_H); break;
case ''i'': doType(VK_I); break;
case ''j'': doType(VK_J); break;
case ''k'': doType(VK_K); break;
case ''l'': doType(VK_L); break;
case ''m'': doType(VK_M); break;
case ''n'': doType(VK_N); break;
case ''o'': doType(VK_O); break;
case ''p'': doType(VK_P); break;
case ''q'': doType(VK_Q); break;
case ''r'': doType(VK_R); break;
case ''s'': doType(VK_S); break;
case ''t'': doType(VK_T); break;
case ''u'': doType(VK_U); break;
case ''v'': doType(VK_V); break;
case ''w'': doType(VK_W); break;
case ''x'': doType(VK_X); break;
case ''y'': doType(VK_Y); break;
case ''z'': doType(VK_Z); break;
case ''A'': doType(VK_SHIFT, VK_A); break;
case ''B'': doType(VK_SHIFT, VK_B); break;
case ''C'': doType(VK_SHIFT, VK_C); break;
case ''D'': doType(VK_SHIFT, VK_D); break;
case ''E'': doType(VK_SHIFT, VK_E); break;
case ''F'': doType(VK_SHIFT, VK_F); break;
case ''G'': doType(VK_SHIFT, VK_G); break;
case ''H'': doType(VK_SHIFT, VK_H); break;
case ''I'': doType(VK_SHIFT, VK_I); break;
case ''J'': doType(VK_SHIFT, VK_J); break;
case ''K'': doType(VK_SHIFT, VK_K); break;
case ''L'': doType(VK_SHIFT, VK_L); break;
case ''M'': doType(VK_SHIFT, VK_M); break;
case ''N'': doType(VK_SHIFT, VK_N); break;
case ''O'': doType(VK_SHIFT, VK_O); break;
case ''P'': doType(VK_SHIFT, VK_P); break;
case ''Q'': doType(VK_SHIFT, VK_Q); break;
case ''R'': doType(VK_SHIFT, VK_R); break;
case ''S'': doType(VK_SHIFT, VK_S); break;
case ''T'': doType(VK_SHIFT, VK_T); break;
case ''U'': doType(VK_SHIFT, VK_U); break;
case ''V'': doType(VK_SHIFT, VK_V); break;
case ''W'': doType(VK_SHIFT, VK_W); break;
case ''X'': doType(VK_SHIFT, VK_X); break;
case ''Y'': doType(VK_SHIFT, VK_Y); break;
case ''Z'': doType(VK_SHIFT, VK_Z); break;
case ''`'': doType(VK_BACK_QUOTE); break;
case ''0'': doType(VK_0); break;
case ''1'': doType(VK_1); break;
case ''2'': doType(VK_2); break;
case ''3'': doType(VK_3); break;
case ''4'': doType(VK_4); break;
case ''5'': doType(VK_5); break;
case ''6'': doType(VK_6); break;
case ''7'': doType(VK_7); break;
case ''8'': doType(VK_8); break;
case ''9'': doType(VK_9); break;
case ''-'': doType(VK_MINUS); break;
case ''='': doType(VK_EQUALS); break;
case ''~'': doType(VK_BACK_QUOTE); break;
case ''!'': doType(VK_SHIFT, VK_EXCLAMATION_MARK); break;
case ''@'': doType(VK_SHIFT, VK_AT); break;
case ''#'': doType(VK_SHIFT, VK_NUMBER_SIGN); break;
case ''$'': doType(VK_SHIFT, VK_DOLLAR); break;
case ''%'': doType(VK_SHIFT, VK_5); break;
case ''^'': doType(VK_SHIFT, VK_CIRCUMFLEX); break;
case ''&'': doType(VK_SHIFT, VK_AMPERSAND); break;
case ''*'': doType(VK_SHIFT, VK_ASTERISK); break;
case ''('': doType(VK_LEFT_PARENTHESIS); break;
case '')'': doType(VK_RIGHT_PARENTHESIS); break;
case ''_'': doType(VK_SHIFT, VK_UNDERSCORE); break;
case ''+'': doType(VK_SHIFT, VK_PLUS); break;
case ''/t'': doType(VK_TAB); break;
case ''/n'': doType(VK_ENTER); break;
case ''['': doType(VK_OPEN_BRACKET); break;
case '']'': doType(VK_CLOSE_BRACKET); break;
case ''//': doType(VK_BACK_SLASH); break;
case ''{'': doType(VK_SHIFT, VK_OPEN_BRACKET); break;
case ''}'': doType(VK_SHIFT, VK_CLOSE_BRACKET); break;
case ''|'': doType(VK_SHIFT, VK_BACK_SLASH); break;
case '';'': doType(VK_SEMICOLON); break;
case '':'': doType(VK_SHIFT, VK_COLON); break;
case ''/''': doType(VK_QUOTE); break;
case ''"'': doType(VK_SHIFT, VK_QUOTEDBL); break;
case '','': doType(VK_COMMA); break;
case ''<'': doType(VK_SHIFT, VK_COMMA); break;
case ''.'': doType(VK_PERIOD); break;
case ''>'': doType(VK_SHIFT, VK_PERIOD); break;
case ''/'': doType(VK_SLASH); break;
case ''?'': doType(VK_SHIFT, VK_SLASH); break;
case '' '': doType(VK_SPACE); break;
case ''/b'': doType(VK_BACK_SPACE); break;
default:
throw new IllegalArgumentException("Cannot type character " + character);
}
}

Answer 9

No conozco el método del mapa de comandos, pero se ve bien, echaré un vistazo.

Finalmente descubro que el código clave de la aa la z es de 65 a 90. Por lo tanto,

private void write(Robot bot, String st) {
char[] arr = st.toCharArray();
int i = arr.length;
int j = 0;
while (j<i) {
int kcode = (int) arr[j] - 32;
bot.keyPress(kcode);
bot.keyRelease(kcode);
j++;
}
}

Simplemente funciona para letras minúsculas (puede corregirlo fácilmente con una prueba simple para mayúsculas).

Por lo que estaba buscando funciona a la perfección :-)

Answer 10

Puedes hacerlo simplemente a través de la API de reflexión de Java:

public void writeKeyboard(Robot bot, String st) {
String upperCase = st.toUpperCase();
for(int i = 0; i < upperCase.length(); i++) {
String letter = Character.toString(upperCase.charAt(i));
String code = "VK_" + letter
Field f = KeyEvent.class.getField(code);
int keyEvent = f.getInt(null);
bot.press(keyEvent);
bot.release(keyEvent);
}
}

Answer 11

Recientemente escribí una clase para hacer esto. Introduce el código Alt de cada personaje, en lugar de calcular la combinación de teclas para cada caso individualmente. No es la solución más rápida, pero es concisa y funciona para una amplia gama de personajes.

import java.awt.AWTException;
import java.awt.Robot;
import static java.awt.event.KeyEvent.VK_ALT;
import static java.awt.event.KeyEvent.VK_NUMPAD0;
public class Altbot extends Robot{
Altbot()throws AWTException{}
public void type(CharSequence cs){
for(int i=0;i<cs.length();i++){
type(cs.charAt(i));
}
}
public void type(char c){
keyPress(VK_ALT);
keyPress(VK_NUMPAD0);
keyRelease(VK_NUMPAD0);
String altCode=Integer.toString(c);
for(int i=0;i<altCode.length();i++){
c=(char)(altCode.charAt(i)+''0'');
//delay(20);//may be needed for certain applications
keyPress(c);
//delay(20);//uncomment if necessary
keyRelease(c);
}
keyRelease(VK_ALT);
}
}

Answer 12

Su código funcionará siempre que use caracteres alfanuméricos solamente, no funcionará para caracteres como ":". SmartRobot clase SmartRobot se encargará de esto.

Answer 13

Tuve el mismo problema. Descubrí que el siguiente código era una forma sencilla de traducir una cadena a eventos clave. Parece que la mayoría de las personas tenía correcciones específicas de implementación para tener en cuenta las diferencias entre mayúsculas y minúsculas. Debido a que las teclas VK no se preocupan por mayúsculas / minúsculas, fundir todo en mayúsculas parece solucionar el problema.

for(int i = 0; i < string.length(); i++){
char c = Character.toUpperCase(s.charAt(i));
KeyEvent ke = new KeyEvent(source, KeyEvent.KEY_PRESSED, System.currentTimeMillis(), 0, (int)c, c);
//do whatever with key event
}

También quería decir que esto funciona bien para letras y números, pero puede no funcionar para otros personajes. Esta técnica traduce la marca de acento / retroceso en el teclado numérico 0 ( VK_NUMPAD0 )

Answer 14

Usé el portapapeles para resolver el problema ...

public static void type(String characters) {
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
StringSelection stringSelection = new StringSelection( characters );
clipboard.setContents(stringSelection, clipboardOwner);
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_CONTROL);
}

Answer 15

Just another example. May become handy.

public void writeKeyboard(Robot robot, String string) {
int ascii;
for(int i = 0; i < string.length(); i++) {
ascii = (int)string.charAt(i);
robot.keyPress(ascii);
robot.delay(10);// choose your time or random it
robot.keyRelease(ascii);
robot.delay(10);
}
}

Answer 16

import java.awt.Robot;
import java.awt.event.KeyEvent;
/**
* @author Trevor
* Handles alpha numerics and common punctuation
*/
public class RobotKeyboard{
private Robot robot;
public RobotKeyboard(Robot robot){
this.robot = robot;
}
public void typeMessage(String message){
for (int i = 0; i < message.length(); i++){
handleRepeatCharacter(message, i);
type(message.charAt(i));
}
}
private void handleRepeatCharacter(String message, int i){
if(i == 0)
return;
//The robot won''t type the same letter twice unless we release a key.
if(message.charAt(i) == message.charAt(i-1)){
robot.keyPress(KeyEvent.VK_SHIFT);
robot.keyRelease(KeyEvent.VK_SHIFT);
}
}
private void type(char character){
handleSpecialCharacter(character);
if (Character.isLowerCase(character)){
typeCharacter(Character.toUpperCase(character));
}
if (Character.isUpperCase(character)){
typeShiftCharacter(character);
}
if (Character.isDigit(character)){
typeCharacter(character);
}
}
private void handleSpecialCharacter(char character){
if (character == '' '')
typeCharacter(KeyEvent.VK_SPACE);
if (character == ''.'')
typeCharacter(KeyEvent.VK_PERIOD);
if (character == ''!'')
typeShiftCharacter(KeyEvent.VK_1);
if (character == ''?'')
typeShiftCharacter(KeyEvent.VK_SLASH);
if (character == '','')
typeCharacter(KeyEvent.VK_COMMA);
//More specials here as needed
}
private void typeCharacter(int character){
robot.keyPress(character);
}
private void typeShiftCharacter(int character){
robot.keyPress(KeyEvent.VK_SHIFT);
robot.keyPress(character);
robot.keyRelease(KeyEvent.VK_SHIFT);
}
}