web-dev-qa-db-fra.com

Convertir une chaîne en événements clés

Je veux convertir une chaîne en KeyEvent pour faire quelque chose comme ceci:

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++;
     }
}
42
Martin Trigaux

J'utilise fondamentalement une déclaration switch glorifiée. Simple et rapide:

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 vous voulez un type de clé personnalisé, vous pouvez étendre la classe et remplacer la méthode type(char). Par exemple:

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;
        }
    }

}

Il y a bien sûr place à amélioration, mais vous voyez l'idée.

80
Adam Paynter

J'ai utilisé le presse-papier pour résoudre le problème ...

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);
}
23
Carl Bosch

Vous pouvez le faire simplement via l'API de réflexion 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);
    }
}
9
Jindra Helcl

J'ai récemment écrit un cours pour le faire. Il entre le code Alt de chaque caractère au lieu de déterminer la combinaison de touches pour chaque cas individuellement. Ce n’est pas la solution la plus rapide, mais elle est concise et convient à un très grand nombre de personnages.

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);
    }
}
6
Ryan Hilbert

Voici comment j'ai réussi à utiliser toutes les clés disponibles. Créez une carte et remplissez-la à l'aide de la méthode fillKeyMap. Vous pouvez maintenant utiliser la représentation sous forme de chaîne des événements clés et la reconvertir en codes KeyEvent à l'aide de la carte.

/** 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) {}
}
4
Dombrovski

C'est un peu un Kludge, mais vous pouvez utiliser le modèle Commande pour encapsuler les séquences de touches de chaque caractère de la chaîne, puis obtenir la commande pour chaque caractère à son tour et invoquer la méthode. L'avantage de cela est que vous n'avez qu'à configurer la carte une seule fois. L'inconvénient est qu'il implique toujours un tas 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);
}

Ensuite, pour utiliser la carte:

for (int i = 0; i < st.length(); i++) {
    String subString = st.substring(i, i + 1);

    commandMap.get(subString).pressKey(bot);
}
3
Rich Seller

J'utilise essentiellement le modèle commande comme le fait Rich Seller dans sa réponse, avec deux modifications mineures dans l'intérêt de la brièveté:

  • utilisation du modèle Decoration pour la réutilisation d'instances de la commande a-z 
  • utilisation de la réflexion pour supprimer KeyEvent.VK _ ???

Interface de commande:

interface Command {

    void pressKey(Robot robot);
}

et le décorateur (pour la modification 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();
    }
}

en utilisant cet assistant (pour la modification 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);
}

M&EACUTE;FIEZ-VOUS: je ne gère pas les exceptions ici, cet exercice est laissé pour vous :)) 

puis en remplissant la commande en utilisant une boucle 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));
    }

Cas de test

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

comme prévu cette sortie:

 a 
 a 
 a 
 SHIFT + b 
 SHIFT + b 
 SHIFT + b 
3
dfa

Votre code fonctionnera aussi longtemps que vous utiliserez des caractères alphanumériques, il ne fonctionnera pas pour des caractères comme ":" SmartRobot class gérera cela.

2
Demiurg

La réponse acceptée me semble très gonflée. Voici une solution un peu plus concise qui est en quelque sorte basée sur la réponse acceptée. Il devrait gérer à peu près tous les cas d'utilisation. Traite également \n (nouvelle ligne), \t (tab) et \b (retour arrière), comme illustré dans l'exemple.

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);
            }
        }
    }
}
2
Sensei_Shoh

Légère modification de la réponse d'Adam Paynter car le code ne fonctionnait pas pour toutes les clés, par exemple. !, @, #, $ etc. (Nécessité d'appuyer d'abord sur VK_SHIFT)

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);
    }
}
1
Varun Kumar

J'ai eu le même problème. J'ai trouvé que le code ci-dessous était un moyen simple de traduire une chaîne en événements clés. Il semble que la plupart des gens avaient des correctifs spécifiques à leur implémentation pour tenir compte des différences entre majuscules et minuscules. Comme les touches VK ne se soucient pas des majuscules/minuscules, tout mettre en majuscules semble résoudre le problème.

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
}

Je voulais aussi dire que cela fonctionne bien pour les lettres et les chiffres, mais que cela ne fonctionnera peut-être pas pour d'autres caractères. Cette technique traduisait la marque d'accent/coup en arrière en pavé numérique 0 (VK_NUMPAD0)

1
Gregory Peck

J'aimerais avoir 50 points de réputation à commenter Adam Paynter solution, mais pas encore ....

Sa classe Keyboard a bien fonctionné, mais des problèmes de touches non alphabétiques, tels que :, \ et /, se sont posés.

La solution que j'ai trouvée consistait à appuyer sur <ALT> et à le maintenir enfoncé pendant la saisie du <ASCII code> de ces clés.

Tout d'abord, j'ai modifié la méthode doType() pour ne conserver que SHIFT et/ou ALTpressed, mais pas chaque clé qui compose le code ASCII. C'est comme ça que les humains utilisent les claviers :)

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);
    }

}

Ensuite, j'ai changé le switch case pour passer ALT et le code 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);

=============================================== ===== ADDITION

J'ai peaufiné un peu plus cette classe:

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);
    }
}
1
cbaldan
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);
    }

}
1
trevorism

Juste un autre exemple. Peut devenir pratique.

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);
    }
}
0
Nelson Macieira

J'ai trouvé que combiner les réponses de Ryan Hilbert et Adam Paynter m'a donné le meilleur résultat. Il combine la vitesse des clés simples avec la robustesse des codes alternatifs. Le code combiné:

/**
 * 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://stackoverflow.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]);
    }

}
0

Je ne connais pas la méthode commandmap mais ça a l'air bien, je vais jeter un coup d'oeil.

Enfin, je découvre que le code d'activation de a à z est compris entre 65 et 90 .

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++;
    }       
}

Cela fonctionne seulement pour les lettres minuscules (vous pouvez facilement le corriger avec un simple test pour les lettres majuscules).

Pour ce que je cherchais, cela fonctionne parfaitement :-)

0
Martin Trigaux