Introduction to the Java Robot Class in Java

Now let's move along to another program that demonstrates use of the keyboard by a Robot object.

Description of the program named Robot05

In addition to creating low-level mouse inputs, an object of the Robot class can create low-level keyboard inputs, just as though a human user were pressing the keys on the keyboard.

Designed to work specifically with Windows OS

As written, this program will run correctly only under the Windows operating system.  This is because it specifically makes use of the Windows program named Notepad.

(However, the program could easily be modified to use a similar editor program under a different operating system.)

Low-level keyboard input

This program illustrates the low-level nature of the behavior of an object of the Robot class by:

• Starting the Windows Notepad editor program in a separate process.
• Using a Robot object to enter text into the Notepad document.

Running the program

This Java program does not have a GUI.  To see the intended behavior of this program, simply start the program running from the command line under the Windows operating system.

Notepad program will start

When this Java program starts running, it causes the Windows Notepad program to start running in a separate process with a new empty document.

Enter text into the Notepad document and terminate

Then this program uses a Robot object to enter the word Hello into the Notepad document.  After that, the Java program terminates.

When the Java program terminates, the Notepad program is still running, and can be saved to a file, or terminated by the user.

Requires SDK V1.3 or later

As mentioned earlier, the Robot class was first released in SDK Version 1.3.  Therefore, as was the case in the previous program, you will need to be running Version 1.3 or later to successfully compile and execute this program.  This program was tested on my machine using SDK 1.4.1 under WinXP

Will discuss in fragments

As usual, I will discuss this program in fragments.  You can view a complete listing of Robot05 in Listing 11 near the end of the lesson.

Need some keycode data

The purpose of this program is to demonstrate the ability of a Java program to enter character data into a non-Java program.  Therefore, we will need some keycode data.

The code in Listing 6 creates an array object containing the virtual keycodes for the word hello.  This data will be used later with the Robot.keyPress and Robot.keyRelease methods, and the KeyEvent.VK_SHIFT virtual keycode, to mimic the behavior of a human user entering the characters Hello into a Notepad document.
 

public class Robot05{
  //Create an array of keycode data
  int keyInput[] = {
      KeyEvent.VK_H,
      KeyEvent.VK_E,
      KeyEvent.VK_L,
      KeyEvent.VK_L,
      KeyEvent.VK_O
  };//end keyInput array

Listing 6

Start Notepad running

The main method begins in Listing 7.  The code in Listing 7 starts the Notepad program running in a separate process.  This should cause the Notepad program to start running and to become the active window, capable of accepting input from the keyboard.

  public static void main(String[] args)
                 throws AWTException,IOException{

    Runtime.getRuntime().exec("notepad");

Listing 7

Runtime is not affiliated with the Robot class

Note that the exec method used in Listing 7 has nothing to do with the Robot class.  The Runtime class and its methods have been available since JDK1.0.

Here is what Sun has to say about the Runtime class.

"Every Java application has a single instance of class Runtime that allows the application to interface with the environment in which the application is running. The current runtime can be obtained from the getRuntime method."

Methods of the Runtime class

The Runtime class provides about twenty instance methods that allow you do unrelated things such as:

• Determine the amount of free memory in the Java Virtual Machine.
• Run the garbage collector.
• Forcibly terminate the currently running Java virtual machine.
• Run the finalization methods of any objects pending finalization.

The exec method of the Runtime class

In addition, the exec method of the Runtime class makes it possible to "execute a specified string as a command in a separate process."

The code in Listing 7 executes the string "notepad" as a command in a separate process.  This, in turn, causes the Windows program named Notepad to start running and to become the active window.

Get a Robot object

The code in Listing 8 gets and saves a reference to a new Robot object, which will be used to enter text characters into the Notepad edit window.
 

    Robot robot = new Robot();

Listing 8

Enter the characters into the Notepad edit window

The code in Listing 9 extracts the keycodes previously stored in the array and invokes the keyPress method to mimic the action of a human typist.  This causes the characters represented by those keycodes to be entered into the Notepad editor.
 

    robot.keyPress(KeyEvent.VK_SHIFT);
    for (int cnt2 = 0;
                 cnt2 < keyInput.length; cnt2++){
      if(cnt2 > 0){
             robot.keyRelease(KeyEvent.VK_SHIFT);
      }//end if
      robot.keyPress(keyInput[cnt2]);
      //Insert a one-half second delay between
      // characters.
      robot.delay(500);
    }//end for loop

  }//main
}//end class Robot05

Listing 9

Note upper and lower case characters

Note the combined use of the keyPress and keyRelease methods along with KeyEvent.VK_SHIFT virtual keycode to mimic the user holding down the Shift key for entry of the first character, H.

A one-half second delay

The code in Listing 9 also inserts a one-half second delay following the entry of each character so that you can see them being individually entered into the Notepad editor.

End of the program

The code in Listing 9 also signals the end of the main method and the end of the program.

After all of the characters have been entered into the Notepad editor, the Java program terminates.

Recap for program Robot05

The program named Robot05 starts a new instance of the program named Notepad running in a separate process, and then enters the characters Hello into the Notepad document.  Then the Java program terminates, leaving the Notepad program running.