RobotAction.java

package edu.stanford.hci.r3.actions.types;

import java.awt.AWTException;
import java.awt.Color;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.ArrayList;
import java.util.List;

import javax.swing.KeyStroke;

import edu.stanford.hci.r3.actions.R3Action;
import edu.stanford.hci.r3.util.graphics.ImageUtils;

public class RobotAction implements R3Action {

        public static enum MouseWheelDirection {
                ROLL_WHEEL_DOWN(1), ROLL_WHEEL_UP(-1);

                private int value;

                private MouseWheelDirection(int val) {
                        value = val;
                }

                public int getValue() {
                        return value;
                }
        }

        public static class RobotCommand {
                private Object[] arguments; // make sure they are of the right type!

                private RobotMethod method;

                public RobotCommand(RobotMethod m, Object... args) {
                        method = m;
                        arguments = args;
                }
        }

        public static enum RobotMethod {
                CREATE_SCREEN_CAPTURE("CreateScreenCapture"), /* does nothing */
                DELAY("Delay"), GET_PIXEL_COLOR("GetPixelColor"), KEY_PRESS("KPress"), KEY_RELEASE("KRelease"), KEY_TYPE(
                                "KType"), MOUSE_MOVE("MMove"), MOUSE_PRESS("MPress"), MOUSE_RELEASE("MRelease"), MOUSE_WHEEL(
                                "MWheel"), SET_AUTO_DELAY("SADelay"), SET_AUTO_WAIT_FOR_IDLE("SAWaitForIdle"), WAIT_FOR_IDLE(
                                "WaitForIdle");

                private String command;

                private RobotMethod(String commandString) {
                        command = commandString;
                }

                public String getCommand() {
                        return command;
                }
        }

        private List<RobotCommand> commandsToRun = new ArrayList<RobotCommand>();

        private int deviceToControl = 0;

        public RobotAction() {

        }

        public void createScreenCapture(Rectangle screenRect, File destFile) {
                commandsToRun.add(new RobotCommand(RobotMethod.CREATE_SCREEN_CAPTURE, screenRect, destFile));
        }

        public void delay(int ms) {
                commandsToRun.add(new RobotCommand(RobotMethod.DELAY, ms));
        }

        public int getNumCommands() {
                return commandsToRun.size();
        }

        public void getPixelColor(int x, int y) {
                commandsToRun.add(new RobotCommand(RobotMethod.GET_PIXEL_COLOR, x, y));
        }

        private Robot getRobot() {
                Robot r = null;
                final GraphicsDevice[] screenDevices = GraphicsEnvironment.getLocalGraphicsEnvironment()
                                .getScreenDevices();
                // if invalid screen device number... just set to 0
                if (!(deviceToControl >= 0 && deviceToControl < screenDevices.length)) {
                        deviceToControl = 0;
                }

                // create it for the specified device
                try {
                        r = new Robot(screenDevices[deviceToControl]);
                } catch (AWTException e) {
                        e.printStackTrace();
                }
                return r;
        }

        public void invoke() {
                // need to get a local Robot every time, because we may have sent this across the wire...
                final Robot rob = getRobot();

                // for each method in our list, invoke it with the correct arguments
                for (RobotCommand command : commandsToRun) {
                        Object[] arguments = command.arguments;
                        RobotMethod method = command.method;

                        // System.out.println("RobotAction: Invoking " + method + " [" +
                        // ArrayUtils.toString(arguments));
                        switch (method) {
                        case CREATE_SCREEN_CAPTURE: // args: rectangle, file
                                BufferedImage image = rob.createScreenCapture((Rectangle) arguments[0]);
                                // save the file locally
                                ImageUtils.writeImageToJPEG(image, 100, (File) arguments[1]);
                                // System.out.println("RobotAction :: Screen Cap Saved");
                                break;
                        case DELAY: // args: int milliseconds
                                rob.delay((Integer) arguments[0]);
                                break;
                        case GET_PIXEL_COLOR: // args: int x, int y
                                final Color pixelColor = rob.getPixelColor((Integer) arguments[0],
                                                (Integer) arguments[1]);
                                System.out.println("RobotAction :: Pixel Color at " + arguments[0] + "," + arguments[1]
                                                + " is " + pixelColor);
                                // TODO: Do something more interesting with this data
                                break;
                        case KEY_PRESS: // arg: int keycode to press
                                rob.keyPress((Integer) arguments[0]);
                                break;
                        case KEY_RELEASE: // arg: int keycode to release
                                rob.keyRelease((Integer) arguments[0]);
                                break;
                        case MOUSE_MOVE: // args: int x, int y
                                // System.out.println("RobotAction :: Moving Mouse... to " + arguments[0] + "," +
                                // arguments[1] + "!");
                                rob.mouseMove((Integer) arguments[0], (Integer) arguments[1]);
                                break;
                        case MOUSE_PRESS: // int mouse button
                                rob.mousePress((Integer) arguments[0]);
                                break;
                        case MOUSE_RELEASE: // int mouse button
                                rob.mouseRelease((Integer) arguments[0]);
                                break;
                        case MOUSE_WHEEL: // int wheel roll amount
                                rob.mouseWheel((Integer) arguments[0]);
                                break;
                        case SET_AUTO_DELAY: // int delay millis
                                rob.setAutoDelay((Integer) arguments[0]);
                                break;
                        case SET_AUTO_WAIT_FOR_IDLE: // boolean wait?
                                rob.setAutoWaitForIdle((Boolean) arguments[0]);
                                break;
                        case WAIT_FOR_IDLE:
                                rob.waitForIdle();
                                break;
                        }

                }
        }

        public void keyPress(int keycode) {
                commandsToRun.add(new RobotCommand(RobotMethod.KEY_PRESS, keycode));
        }

        public void keyRelease(int keycode) {
                commandsToRun.add(new RobotCommand(RobotMethod.KEY_RELEASE, keycode));
        }

        public void keyType(int keycode) {
                keyPress(keycode);
                keyRelease(keycode);
        }

        public void mouseMove(int x, int y) {
                commandsToRun.add(new RobotCommand(RobotMethod.MOUSE_MOVE, x, y));
        }

        public void mousePress(int buttons) {
                commandsToRun.add(new RobotCommand(RobotMethod.MOUSE_PRESS, buttons));
        }

        public void mouseRelease(int buttons) {
                commandsToRun.add(new RobotCommand(RobotMethod.MOUSE_RELEASE, buttons));
        }

        public void mouseWheel(int wheelAmt, MouseWheelDirection direction) {
                commandsToRun.add(new RobotCommand(RobotMethod.MOUSE_WHEEL, Math.abs(wheelAmt)
                                * direction.getValue()));
        }

        public void setAutoDelay(int ms) {
                commandsToRun.add(new RobotCommand(RobotMethod.SET_AUTO_DELAY, ms));
        }

        public void setAutoWaitForIdle(boolean isOn) {
                commandsToRun.add(new RobotCommand(RobotMethod.SET_AUTO_WAIT_FOR_IDLE, isOn));
        }

        public void setScreenDevice(int requestedDevice) {
                deviceToControl = requestedDevice;
        }

        public void typeString(String text) {
                char[] cs = text.toCharArray();
                for (char key : cs) {
                        keyType(KeyStroke.getKeyStroke(key).getKeyCode());
                }
        }

        public void waitForIdle() {
                commandsToRun.add(new RobotCommand(RobotMethod.WAIT_FOR_IDLE));
        }

}

---