tools/monkeyrunner/src/com/android/monkeyrunner/MonkeyRunner.java - platform/development - Git at Google

 /*
  * Copyright (C) 2009 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.monkeyrunner;

 import com.android.ddmlib.AndroidDebugBridge;
 import com.android.ddmlib.IDevice;
 import com.android.ddmlib.Log;
 import com.android.ddmlib.NullOutputReceiver;
 import com.android.ddmlib.RawImage;
 import com.android.ddmlib.Log.ILogOutput;
 import com.android.ddmlib.Log.LogLevel;

 import java.awt.image.BufferedImage;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.InetAddress;
 import java.net.Socket;
 import java.net.UnknownHostException;
 import java.util.logging.Level;
 import java.util.logging.Logger;

 import javax.imageio.ImageIO;

 /**
  *  MonkeyRunner is a host side application to control a monkey instance on a
  *  device. MonkeyRunner provides some useful helper functions to control the
  *  device as well as various other methods to help script tests.
  */
 public class MonkeyRunner {

   static String monkeyServer = "127.0.0.1";
   static int monkeyPort = 1080;
   static Socket monkeySocket = null;

   static IDevice monkeyDevice;

   static BufferedReader monkeyReader;
   static BufferedWriter monkeyWriter;
   static String monkeyResponse;

   static MonkeyRecorder monkeyRecorder;

   static String scriptName = null;

   // Obtain a suitable logger.
   private static Logger logger = Logger.getLogger("com.android.monkeyrunner");

   // delay between key events
   final static int KEY_INPUT_DELAY = 1000;

   // version of monkey runner
   final static String monkeyRunnerVersion = "0.31";

   // TODO: interface cmd; class xml tags; fix logger; test class/script

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

     // haven't figure out how to get below INFO...bad parent.  Pass -v INFO to turn on logging
     logger.setLevel(Level.parse("WARNING"));
     processOptions(args);

     logger.info("initAdb");
     initAdbConnection();
     logger.info("openMonkeyConnection");
     openMonkeyConnection();

     logger.info("start_script");
     start_script();

     logger.info("ScriptRunner.run");
     ScriptRunner.run(scriptName);

     logger.info("end_script");
     end_script();
     logger.info("closeMonkeyConnection");
     closeMonkeyConnection();
   }

   /**
    *  Initialize an adb session with a device connected to the host
    *
    */
   public static void initAdbConnection() {
     String adbLocation = "adb";
     boolean device = false;
     boolean emulator = false;
     String serial = null;

     AndroidDebugBridge.init(false /* debugger support */);

     try {
       AndroidDebugBridge bridge = AndroidDebugBridge.createBridge(
           adbLocation, true /* forceNewBridge */);

       // we can't just ask for the device list right away, as the internal thread getting
       // them from ADB may not be done getting the first list.
       // Since we don't really want getDevices() to be blocking, we wait here manually.
       int count = 0;
       while (bridge.hasInitialDeviceList() == false) {
         try {
           Thread.sleep(100);
           count++;
         } catch (InterruptedException e) {
           // pass
         }

         // let's not wait > 10 sec.
         if (count > 100) {
           System.err.println("Timeout getting device list!");
           return;
         }
       }

       // now get the devices
       IDevice[] devices = bridge.getDevices();

       if (devices.length == 0) {
         printAndExit("No devices found!", true /* terminate */);
       }

       monkeyDevice = null;

       if (emulator || device) {
         for (IDevice d : devices) {
           // this test works because emulator and device can't both be true at the same
           // time.
           if (d.isEmulator() == emulator) {
             // if we already found a valid target, we print an error and return.
             if (monkeyDevice != null) {
               if (emulator) {
                 printAndExit("Error: more than one emulator launched!",
                     true /* terminate */);
               } else {
                 printAndExit("Error: more than one device connected!",true /* terminate */);
               }
             }
             monkeyDevice = d;
           }
         }
       } else if (serial != null) {
         for (IDevice d : devices) {
           if (serial.equals(d.getSerialNumber())) {
             monkeyDevice = d;
             break;
           }
         }
       } else {
         if (devices.length > 1) {
           printAndExit("Error: more than one emulator or device available!",
               true /* terminate */);
         }
         monkeyDevice = devices[0];
       }

       monkeyDevice.createForward(monkeyPort, monkeyPort);
       String command = "monkey --port " + monkeyPort;
       monkeyDevice.executeShellCommand(command, new NullOutputReceiver());

     } catch(IOException e) {
       e.printStackTrace();
     }
   }

   /**
    * Open a tcp session over adb with the device to communicate monkey commands
    */
   public static void openMonkeyConnection() {
     try {
       InetAddress addr = InetAddress.getByName(monkeyServer);
       monkeySocket = new Socket(addr, monkeyPort);
       monkeyWriter = new BufferedWriter(new OutputStreamWriter(monkeySocket.getOutputStream()));
       monkeyReader = new BufferedReader(new InputStreamReader(monkeySocket.getInputStream()));
     } catch (UnknownHostException e) {
       e.printStackTrace();
     } catch(IOException e) {
       e.printStackTrace();
     }
   }

   /**
    * Close tcp session with the monkey on the device
    *
    */
   public static void closeMonkeyConnection() {
     try {
       monkeyReader.close();
       monkeyWriter.close();
       monkeySocket.close();
       AndroidDebugBridge.terminate();
     } catch(IOException e) {
       e.printStackTrace();
     }
   }

   /**
    * This is a house cleaning routine to run before starting a script. Puts
    * the device in a known state and starts recording interesting info.
    */
   public static void start_script() throws IOException {
     press("menu", false);
     press("menu", false);
     press("home", false);

     // Start recording the script output, might want md5 signature of file for completeness
     monkeyRecorder = new MonkeyRecorder(scriptName);

     // Record what device and version of software we are running on
     monkeyRecorder.addAttribute("monkeyRunnerVersion", monkeyRunnerVersion);
     addDeviceVars();
     monkeyRecorder.addComment("Script commands");
   }

   /**
    * This is a house cleaning routine to run after finishing a script.
    * Puts the monkey server in a known state and closes the recording.
    */
   public static void end_script() throws IOException {
     String command = "done";
     sendMonkeyEvent(command, false, false);

     // Stop the recording and zip up the results
     monkeyRecorder.close();
   }

   /** This is a method for scripts to launch an activity on the device
    *
    * @param name The name of the activity to launch
    */
   public static void launch_activity(String name) throws IOException {
     System.out.println("Launching: " + name);
     recordCommand("Launching: " + name);
     monkeyDevice.executeShellCommand("am start -a android.intent.action.MAIN -n "
         + name, new NullOutputReceiver());
     // void return, so no response given, just close the command element in the xml file.
     monkeyRecorder.endCommand();
    }

   /**
    * Grabs the current state of the screen stores it as a png
    *
    * @param tag filename or tag descriptor of the screenshot
    */
   public static void grabscreen(String tag) throws IOException {
     tag += ".png";

     try {
       Thread.sleep(1000);
       getDeviceImage(monkeyDevice, tag, false);
     } catch (InterruptedException e) {
     }
   }

   /**
    * Sleeper method for script to call
    *
    * @param msec msecs to sleep for
    */
   public static void sleep(int msec) throws IOException {
     try {
       recordCommand("sleep: " + msec);
       Thread.sleep(msec);
       recordResponse("OK");
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
   }

   /**
    * Tap function for scripts to call at a particular x and y location
    *
    * @param x x-coordinate
    * @param y y-coordinate
    */
   public static boolean tap(int x, int y) throws IOException {
     String command = "tap " + x + " " + y;
     boolean result = sendMonkeyEvent(command);
     return result;
   }

   /**
    * Press function for scripts to call on a particular button or key
    *
    * @param key key to press
    */
   public static boolean press(String key) throws IOException {
     return press(key, true);
   }

   /**
    * Press function for scripts to call on a particular button or key
    *
    * @param key key to press
    * @param print whether to send output to user
    */
   private static boolean press(String key, boolean print) throws IOException {
     String command = "press " + key;
     boolean result = sendMonkeyEvent(command, print, true);
     return result;
   }

   /**
    * dpad down function
    */
   public static boolean down() throws IOException {
     return press("dpad_down");
   }

   /**
    * dpad up function
    */
   public static boolean up() throws IOException {
     return press("dpad_up");
   }

   /**
    * Function to type text on the device
    *
    * @param text text to type
    */
   public static boolean type(String text) throws IOException {
     boolean result = false;
     // text might have line ends, which signal new monkey command, so we have to eat and reissue
     String[] lines = text.split("[\\r\\n]+");
     for (String line: lines) {
       result = sendMonkeyEvent("type " + line + "\n");
     }
     // return last result.  Should never fail..?
     return result;
   }

   /**
    * Function to get a static variable from the device
    *
    * @param name name of static variable to get
    */
   public static boolean getvar(String name) throws IOException {
     return sendMonkeyEvent("getvar " + name + "\n");
   }

   /**
    * Function to get the list of static variables from the device
    */
   public static boolean listvar() throws IOException {
     return sendMonkeyEvent("listvar \n");
   }

   /**
    * This function is the communication bridge between the host and the device.
    * It sends monkey events and waits for responses over the adb tcp socket.
    * This version if for all scripted events so that they get recorded and reported to user.
    *
    * @param command the monkey command to send to the device
    */
   private static boolean sendMonkeyEvent(String command) throws IOException {
     return sendMonkeyEvent(command, true, true);
   }

   /**
    * This function allows the communication bridge between the host and the device
    * to be invisible to the script for internal needs.
    * It splits a command into monkey events and waits for responses for each over an adb tcp socket.
    * Returns on an error, else continues and sets up last response.
    *
    * @param command the monkey command to send to the device
    * @param print whether to print out the responses to the user
    * @param record whether to put the command in the xml file that stores test outputs
    */
   private static boolean sendMonkeyEvent(String command, Boolean print, Boolean record) throws IOException {
     command = command.trim();
     if (print)
       System.out.println("MonkeyCommand: " + command);
     if (record)
       recordCommand(command);
     logger.info("Monkey Command: " + command + ".");

     // send a single command and get the response
     monkeyWriter.write(command + "\n");
     monkeyWriter.flush();
     monkeyResponse = monkeyReader.readLine();

     if(monkeyResponse != null) {
       // if a command returns with a response
       if (print)
         System.out.println("MonkeyServer: " + monkeyResponse);
       if (record)
         recordResponse(monkeyResponse);
       logger.info("Monkey Response: " + monkeyResponse + ".");

       // return on error
       if (monkeyResponse.startsWith("ERROR"))
         return false;

       // return on ok
       if(monkeyResponse.startsWith("OK"))
         return true;

       // return on something else?
       return false;
     }
     // didn't get a response...
     if (print)
       System.out.println("MonkeyServer: ??no response");
     if (record)
       recordResponse("??no response");
     logger.info("Monkey Response: ??no response.");

     //return on no response
     return false;
   }

   /**
    * Record the command in the xml file
    *
    * @param command the command sent to the monkey server
    */
   private static void recordCommand(String command) throws IOException {
     if (monkeyRecorder != null) {                       // don't record setup junk
       monkeyRecorder.startCommand();
       monkeyRecorder.addInput(command);
     }
   }

   /**
    * Record the response in the xml file
    *
    * @param response the response sent by the monkey server
    */
   private static void recordResponse(String response) throws IOException {
     recordResponse(response, "");
   }

   /**
    * Record the response and the filename in the xml file, store the file (to be zipped up later)
    *
    * @param response the response sent by the monkey server
    * @param filename the filename of a file to be time stamped, recorded in the xml file and stored
    */
   private static void recordResponse(String response, String filename) throws IOException {
     if (monkeyRecorder != null) {                    // don't record setup junk
       monkeyRecorder.addResult(response, filename);  // ignores file if filename empty
       monkeyRecorder.endCommand();
     }
   }

   /**
    * Add the device variables to the xml file in monkeyRecorder.
    * The results get added as device_var tags in the script_run tag
    */
   private static void addDeviceVars() throws IOException {
     monkeyRecorder.addComment("Device specific variables");
     sendMonkeyEvent("listvar \n", false, false);
     if (monkeyResponse.startsWith("OK:")) {
       // peel off "OK:" string and get the individual var names
       String[] varNames = monkeyResponse.substring(3).split("\\s+");
       // grab all the individual var values
       for (String name: varNames) {
         sendMonkeyEvent("getvar " + name, false, false);
         if(monkeyResponse != null) {
           if (monkeyResponse.startsWith("OK") ) {
             if (monkeyResponse.length() > 2) {
               monkeyRecorder.addDeviceVar(name, monkeyResponse.substring(3));
             } else {
               // only got OK - good variable but no value
               monkeyRecorder.addDeviceVar(name, "null");
             }
           } else {
             // error returned - couldn't get var value for name... include error return
             monkeyRecorder.addDeviceVar(name, monkeyResponse);
           }
         } else {
           // no monkeyResponse - bad variable with no value
           monkeyRecorder.addDeviceVar(name, "null");
         }
       }
     } else {
       // it's an error, can't find variable names...
       monkeyRecorder.addAttribute("listvar", monkeyResponse);
     }
   }

   /**
    * Process the command-line options
    *
    * @return Returns true if options were parsed with no apparent errors.
    */
   private static void processOptions(String[] args) {
     // parse command line parameters.
     int index = 0;

     do {
       String argument = args[index++];

       if ("-s".equals(argument)) {
         if(index == args.length) {
           printUsageAndQuit("Missing Server after -s");
         }

         monkeyServer = args[index++];

       } else if ("-p".equals(argument)) {
         // quick check on the next argument.
         if (index == args.length) {
           printUsageAndQuit("Missing Server port after -p");
         }

         monkeyPort = Integer.parseInt(args[index++]);

       } else if ("-v".equals(argument)) {
         // quick check on the next argument.
         if (index == args.length) {
           printUsageAndQuit("Missing Log Level after -v");
         }

         Level level = Level.parse(args[index++]);
         logger.setLevel(level);
         level = logger.getLevel();
         System.out.println("Log level set to: " + level + "(" + level.intValue() + ").");
         System.out.println("Warning: Log levels below INFO(800) not working currently... parent issues");

       } else if (argument.startsWith("-")) {
         // we have an unrecognized argument.
         printUsageAndQuit("Unrecognized argument: " + argument + ".");

         monkeyPort = Integer.parseInt(args[index++]);

       } else {
         // get the filepath of the script to run.  This will be the last undashed argument.
         scriptName = argument;
       }
     } while (index < args.length);
   }

   /*
    * Grab an image from an ADB-connected device.
    */
   private static void getDeviceImage(IDevice device, String filepath, boolean landscape)
   throws IOException {
     RawImage rawImage;
     recordCommand("grabscreen");
     System.out.println("Grabbing Screeshot: " + filepath + ".");

     try {
       rawImage = device.getScreenshot();
     }
     catch (IOException ioe) {
       recordResponse("No frame buffer", "");
       printAndExit("Unable to get frame buffer: " + ioe.getMessage(), true /* terminate */);
       return;
     }

     // device/adb not available?
     if (rawImage == null) {
       recordResponse("No image", "");
       return;
     }

     assert rawImage.bpp == 16;

     BufferedImage image;

     logger.info("Raw Image - height: " + rawImage.height + ", width: " + rawImage.width);

     if (landscape) {
       // convert raw data to an Image
       image = new BufferedImage(rawImage.height, rawImage.width,
           BufferedImage.TYPE_INT_ARGB);

       byte[] buffer = rawImage.data;
       int index = 0;
       for (int y = 0 ; y < rawImage.height ; y++) {
         for (int x = 0 ; x < rawImage.width ; x++) {

           int value = buffer[index++] & 0x00FF;
           value |= (buffer[index++] << 8) & 0x0FF00;

           int r = ((value >> 11) & 0x01F) << 3;
           int g = ((value >> 5) & 0x03F) << 2;
           int b = ((value >> 0) & 0x01F) << 3;

           value = 0xFF << 24 | r << 16 | g << 8 | b;

           image.setRGB(y, rawImage.width - x - 1, value);
         }
       }
     } else {
       // convert raw data to an Image
       image = new BufferedImage(rawImage.width, rawImage.height,
           BufferedImage.TYPE_INT_ARGB);

       byte[] buffer = rawImage.data;
       int index = 0;
       for (int y = 0 ; y < rawImage.height ; y++) {
         for (int x = 0 ; x < rawImage.width ; x++) {

           int value = buffer[index++] & 0x00FF;
           value |= (buffer[index++] << 8) & 0x0FF00;

           int r = ((value >> 11) & 0x01F) << 3;
           int g = ((value >> 5) & 0x03F) << 2;
           int b = ((value >> 0) & 0x01F) << 3;

           value = 0xFF << 24 | r << 16 | g << 8 | b;

           image.setRGB(x, y, value);
         }
       }
     }

     if (!ImageIO.write(image, "png", new File(filepath))) {
       recordResponse("No png writer", "");
       throw new IOException("Failed to find png writer");
     }
     recordResponse("OK", filepath);
   }

   private static void printUsageAndQuit(String message) {
     // 80 cols marker:  01234567890123456789012345678901234567890123456789012345678901234567890123456789
     System.out.println(message);
     System.out.println("Usage: monkeyrunner [options] SCRIPT_FILE");
     System.out.println("");
     System.out.println("    -s      MonkeyServer IP Address.");
     System.out.println("    -p      MonkeyServer TCP Port.");
     System.out.println("    -v      MonkeyServer Logging level (ALL, FINEST, FINER, FINE, CONFIG, INFO, WARNING, SEVERE, OFF)");
     System.out.println("");
     System.out.println("");

     System.exit(1);
   }

   private static void printAndExit(String message, boolean terminate) {
     System.out.println(message);
     if (terminate) {
       AndroidDebugBridge.terminate();
     }
     System.exit(1);
   }
 }
	/*
	* Copyright (C) 2009 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.monkeyrunner;

	import com.android.ddmlib.AndroidDebugBridge;
	import com.android.ddmlib.IDevice;
	import com.android.ddmlib.Log;
	import com.android.ddmlib.NullOutputReceiver;
	import com.android.ddmlib.RawImage;
	import com.android.ddmlib.Log.ILogOutput;
	import com.android.ddmlib.Log.LogLevel;

	import java.awt.image.BufferedImage;

	import java.io.BufferedReader;
	import java.io.BufferedWriter;
	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.OutputStreamWriter;
	import java.net.InetAddress;
	import java.net.Socket;
	import java.net.UnknownHostException;
	import java.util.logging.Level;
	import java.util.logging.Logger;

	import javax.imageio.ImageIO;

	/**
	* MonkeyRunner is a host side application to control a monkey instance on a
	* device. MonkeyRunner provides some useful helper functions to control the
	* device as well as various other methods to help script tests.
	*/
	public class MonkeyRunner {

	static String monkeyServer = "127.0.0.1";
	static int monkeyPort = 1080;
	static Socket monkeySocket = null;

	static IDevice monkeyDevice;

	static BufferedReader monkeyReader;
	static BufferedWriter monkeyWriter;
	static String monkeyResponse;

	static MonkeyRecorder monkeyRecorder;

	static String scriptName = null;

	// Obtain a suitable logger.
	private static Logger logger = Logger.getLogger("com.android.monkeyrunner");

	// delay between key events
	final static int KEY_INPUT_DELAY = 1000;

	// version of monkey runner
	final static String monkeyRunnerVersion = "0.31";

	// TODO: interface cmd; class xml tags; fix logger; test class/script

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

	// haven't figure out how to get below INFO...bad parent. Pass -v INFO to turn on logging
	logger.setLevel(Level.parse("WARNING"));
	processOptions(args);

	logger.info("initAdb");
	initAdbConnection();
	logger.info("openMonkeyConnection");
	openMonkeyConnection();

	logger.info("start_script");
	start_script();

	logger.info("ScriptRunner.run");
	ScriptRunner.run(scriptName);

	logger.info("end_script");
	end_script();
	logger.info("closeMonkeyConnection");
	closeMonkeyConnection();
	}

	/**
	* Initialize an adb session with a device connected to the host
	*
	*/
	public static void initAdbConnection() {
	String adbLocation = "adb";
	boolean device = false;
	boolean emulator = false;
	String serial = null;

	AndroidDebugBridge.init(false /* debugger support */);

	try {
	AndroidDebugBridge bridge = AndroidDebugBridge.createBridge(
	adbLocation, true /* forceNewBridge */);

	// we can't just ask for the device list right away, as the internal thread getting
	// them from ADB may not be done getting the first list.
	// Since we don't really want getDevices() to be blocking, we wait here manually.
	int count = 0;
	while (bridge.hasInitialDeviceList() == false) {
	try {
	Thread.sleep(100);
	count++;
	} catch (InterruptedException e) {
	// pass
	}

	// let's not wait > 10 sec.
	if (count > 100) {
	System.err.println("Timeout getting device list!");
	return;
	}
	}

	// now get the devices
	IDevice[] devices = bridge.getDevices();

	if (devices.length == 0) {
	printAndExit("No devices found!", true /* terminate */);
	}

	monkeyDevice = null;

	if (emulator \|\| device) {
	for (IDevice d : devices) {
	// this test works because emulator and device can't both be true at the same
	// time.
	if (d.isEmulator() == emulator) {
	// if we already found a valid target, we print an error and return.
	if (monkeyDevice != null) {
	if (emulator) {
	printAndExit("Error: more than one emulator launched!",
	true /* terminate */);
	} else {
	printAndExit("Error: more than one device connected!",true /* terminate */);
	}
	}
	monkeyDevice = d;
	}
	}
	} else if (serial != null) {
	for (IDevice d : devices) {
	if (serial.equals(d.getSerialNumber())) {
	monkeyDevice = d;
	break;
	}
	}
	} else {
	if (devices.length > 1) {
	printAndExit("Error: more than one emulator or device available!",
	true /* terminate */);
	}
	monkeyDevice = devices[0];
	}

	monkeyDevice.createForward(monkeyPort, monkeyPort);
	String command = "monkey --port " + monkeyPort;
	monkeyDevice.executeShellCommand(command, new NullOutputReceiver());

	} catch(IOException e) {
	e.printStackTrace();
	}
	}

	/**
	* Open a tcp session over adb with the device to communicate monkey commands
	*/
	public static void openMonkeyConnection() {
	try {
	InetAddress addr = InetAddress.getByName(monkeyServer);
	monkeySocket = new Socket(addr, monkeyPort);
	monkeyWriter = new BufferedWriter(new OutputStreamWriter(monkeySocket.getOutputStream()));
	monkeyReader = new BufferedReader(new InputStreamReader(monkeySocket.getInputStream()));
	} catch (UnknownHostException e) {
	e.printStackTrace();
	} catch(IOException e) {
	e.printStackTrace();
	}
	}

	/**
	* Close tcp session with the monkey on the device
	*
	*/
	public static void closeMonkeyConnection() {
	try {
	monkeyReader.close();
	monkeyWriter.close();
	monkeySocket.close();
	AndroidDebugBridge.terminate();
	} catch(IOException e) {
	e.printStackTrace();
	}
	}

	/**
	* This is a house cleaning routine to run before starting a script. Puts
	* the device in a known state and starts recording interesting info.
	*/
	public static void start_script() throws IOException {
	press("menu", false);
	press("menu", false);
	press("home", false);

	// Start recording the script output, might want md5 signature of file for completeness
	monkeyRecorder = new MonkeyRecorder(scriptName);

	// Record what device and version of software we are running on
	monkeyRecorder.addAttribute("monkeyRunnerVersion", monkeyRunnerVersion);
	addDeviceVars();
	monkeyRecorder.addComment("Script commands");
	}

	/**
	* This is a house cleaning routine to run after finishing a script.
	* Puts the monkey server in a known state and closes the recording.
	*/
	public static void end_script() throws IOException {
	String command = "done";
	sendMonkeyEvent(command, false, false);

	// Stop the recording and zip up the results
	monkeyRecorder.close();
	}

	/** This is a method for scripts to launch an activity on the device
	*
	* @param name The name of the activity to launch
	*/
	public static void launch_activity(String name) throws IOException {
	System.out.println("Launching: " + name);
	recordCommand("Launching: " + name);
	monkeyDevice.executeShellCommand("am start -a android.intent.action.MAIN -n "
	+ name, new NullOutputReceiver());
	// void return, so no response given, just close the command element in the xml file.
	monkeyRecorder.endCommand();
	}

	/**
	* Grabs the current state of the screen stores it as a png
	*
	* @param tag filename or tag descriptor of the screenshot
	*/
	public static void grabscreen(String tag) throws IOException {
	tag += ".png";

	try {
	Thread.sleep(1000);
	getDeviceImage(monkeyDevice, tag, false);
	} catch (InterruptedException e) {
	}
	}

	/**
	* Sleeper method for script to call
	*
	* @param msec msecs to sleep for
	*/
	public static void sleep(int msec) throws IOException {
	try {
	recordCommand("sleep: " + msec);
	Thread.sleep(msec);
	recordResponse("OK");
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}

	/**
	* Tap function for scripts to call at a particular x and y location
	*
	* @param x x-coordinate
	* @param y y-coordinate
	*/
	public static boolean tap(int x, int y) throws IOException {
	String command = "tap " + x + " " + y;
	boolean result = sendMonkeyEvent(command);
	return result;
	}

	/**
	* Press function for scripts to call on a particular button or key
	*
	* @param key key to press
	*/
	public static boolean press(String key) throws IOException {
	return press(key, true);
	}

	/**
	* Press function for scripts to call on a particular button or key
	*
	* @param key key to press
	* @param print whether to send output to user
	*/
	private static boolean press(String key, boolean print) throws IOException {
	String command = "press " + key;
	boolean result = sendMonkeyEvent(command, print, true);
	return result;
	}

	/**
	* dpad down function
	*/
	public static boolean down() throws IOException {
	return press("dpad_down");
	}

	/**
	* dpad up function
	*/
	public static boolean up() throws IOException {
	return press("dpad_up");
	}

	/**
	* Function to type text on the device
	*
	* @param text text to type
	*/
	public static boolean type(String text) throws IOException {
	boolean result = false;
	// text might have line ends, which signal new monkey command, so we have to eat and reissue
	String[] lines = text.split("[\\r\\n]+");
	for (String line: lines) {
	result = sendMonkeyEvent("type " + line + "\n");
	}
	// return last result. Should never fail..?
	return result;
	}

	/**
	* Function to get a static variable from the device
	*
	* @param name name of static variable to get
	*/
	public static boolean getvar(String name) throws IOException {
	return sendMonkeyEvent("getvar " + name + "\n");
	}

	/**
	* Function to get the list of static variables from the device
	*/
	public static boolean listvar() throws IOException {
	return sendMonkeyEvent("listvar \n");
	}

	/**
	* This function is the communication bridge between the host and the device.
	* It sends monkey events and waits for responses over the adb tcp socket.
	* This version if for all scripted events so that they get recorded and reported to user.
	*
	* @param command the monkey command to send to the device
	*/
	private static boolean sendMonkeyEvent(String command) throws IOException {
	return sendMonkeyEvent(command, true, true);
	}

	/**
	* This function allows the communication bridge between the host and the device
	* to be invisible to the script for internal needs.
	* It splits a command into monkey events and waits for responses for each over an adb tcp socket.
	* Returns on an error, else continues and sets up last response.
	*
	* @param command the monkey command to send to the device
	* @param print whether to print out the responses to the user
	* @param record whether to put the command in the xml file that stores test outputs
	*/
	private static boolean sendMonkeyEvent(String command, Boolean print, Boolean record) throws IOException {
	command = command.trim();
	if (print)
	System.out.println("MonkeyCommand: " + command);
	if (record)
	recordCommand(command);
	logger.info("Monkey Command: " + command + ".");

	// send a single command and get the response
	monkeyWriter.write(command + "\n");
	monkeyWriter.flush();
	monkeyResponse = monkeyReader.readLine();

	if(monkeyResponse != null) {
	// if a command returns with a response
	if (print)
	System.out.println("MonkeyServer: " + monkeyResponse);
	if (record)
	recordResponse(monkeyResponse);
	logger.info("Monkey Response: " + monkeyResponse + ".");

	// return on error
	if (monkeyResponse.startsWith("ERROR"))
	return false;

	// return on ok
	if(monkeyResponse.startsWith("OK"))
	return true;

	// return on something else?
	return false;
	}
	// didn't get a response...
	if (print)
	System.out.println("MonkeyServer: ??no response");
	if (record)
	recordResponse("??no response");
	logger.info("Monkey Response: ??no response.");

	//return on no response
	return false;
	}

	/**
	* Record the command in the xml file
	*
	* @param command the command sent to the monkey server
	*/
	private static void recordCommand(String command) throws IOException {
	if (monkeyRecorder != null) { // don't record setup junk
	monkeyRecorder.startCommand();
	monkeyRecorder.addInput(command);
	}
	}

	/**
	* Record the response in the xml file
	*
	* @param response the response sent by the monkey server
	*/
	private static void recordResponse(String response) throws IOException {
	recordResponse(response, "");
	}

	/**
	* Record the response and the filename in the xml file, store the file (to be zipped up later)
	*
	* @param response the response sent by the monkey server
	* @param filename the filename of a file to be time stamped, recorded in the xml file and stored
	*/
	private static void recordResponse(String response, String filename) throws IOException {
	if (monkeyRecorder != null) { // don't record setup junk
	monkeyRecorder.addResult(response, filename); // ignores file if filename empty
	monkeyRecorder.endCommand();
	}
	}

	/**
	* Add the device variables to the xml file in monkeyRecorder.
	* The results get added as device_var tags in the script_run tag
	*/
	private static void addDeviceVars() throws IOException {
	monkeyRecorder.addComment("Device specific variables");
	sendMonkeyEvent("listvar \n", false, false);
	if (monkeyResponse.startsWith("OK:")) {
	// peel off "OK:" string and get the individual var names
	String[] varNames = monkeyResponse.substring(3).split("\\s+");
	// grab all the individual var values
	for (String name: varNames) {
	sendMonkeyEvent("getvar " + name, false, false);
	if(monkeyResponse != null) {
	if (monkeyResponse.startsWith("OK") ) {
	if (monkeyResponse.length() > 2) {
	monkeyRecorder.addDeviceVar(name, monkeyResponse.substring(3));
	} else {
	// only got OK - good variable but no value
	monkeyRecorder.addDeviceVar(name, "null");
	}
	} else {
	// error returned - couldn't get var value for name... include error return
	monkeyRecorder.addDeviceVar(name, monkeyResponse);
	}
	} else {
	// no monkeyResponse - bad variable with no value
	monkeyRecorder.addDeviceVar(name, "null");
	}
	}
	} else {
	// it's an error, can't find variable names...
	monkeyRecorder.addAttribute("listvar", monkeyResponse);
	}
	}

	/**
	* Process the command-line options
	*
	* @return Returns true if options were parsed with no apparent errors.
	*/
	private static void processOptions(String[] args) {
	// parse command line parameters.
	int index = 0;

	do {
	String argument = args[index++];

	if ("-s".equals(argument)) {
	if(index == args.length) {
	printUsageAndQuit("Missing Server after -s");
	}

	monkeyServer = args[index++];

	} else if ("-p".equals(argument)) {
	// quick check on the next argument.
	if (index == args.length) {
	printUsageAndQuit("Missing Server port after -p");
	}

	monkeyPort = Integer.parseInt(args[index++]);

	} else if ("-v".equals(argument)) {
	// quick check on the next argument.
	if (index == args.length) {
	printUsageAndQuit("Missing Log Level after -v");
	}

	Level level = Level.parse(args[index++]);
	logger.setLevel(level);
	level = logger.getLevel();
	System.out.println("Log level set to: " + level + "(" + level.intValue() + ").");
	System.out.println("Warning: Log levels below INFO(800) not working currently... parent issues");

	} else if (argument.startsWith("-")) {
	// we have an unrecognized argument.
	printUsageAndQuit("Unrecognized argument: " + argument + ".");

	monkeyPort = Integer.parseInt(args[index++]);

	} else {
	// get the filepath of the script to run. This will be the last undashed argument.
	scriptName = argument;
	}
	} while (index < args.length);
	}

	/*
	* Grab an image from an ADB-connected device.
	*/
	private static void getDeviceImage(IDevice device, String filepath, boolean landscape)
	throws IOException {
	RawImage rawImage;
	recordCommand("grabscreen");
	System.out.println("Grabbing Screeshot: " + filepath + ".");

	try {
	rawImage = device.getScreenshot();
	}
	catch (IOException ioe) {
	recordResponse("No frame buffer", "");
	printAndExit("Unable to get frame buffer: " + ioe.getMessage(), true /* terminate */);
	return;
	}

	// device/adb not available?
	if (rawImage == null) {
	recordResponse("No image", "");
	return;
	}

	assert rawImage.bpp == 16;

	BufferedImage image;

	logger.info("Raw Image - height: " + rawImage.height + ", width: " + rawImage.width);

	if (landscape) {
	// convert raw data to an Image
	image = new BufferedImage(rawImage.height, rawImage.width,
	BufferedImage.TYPE_INT_ARGB);

	byte[] buffer = rawImage.data;
	int index = 0;
	for (int y = 0 ; y < rawImage.height ; y++) {
	for (int x = 0 ; x < rawImage.width ; x++) {

	int value = buffer[index++] & 0x00FF;
	value \|= (buffer[index++] << 8) & 0x0FF00;

	int r = ((value >> 11) & 0x01F) << 3;
	int g = ((value >> 5) & 0x03F) << 2;
	int b = ((value >> 0) & 0x01F) << 3;

	value = 0xFF << 24 \| r << 16 \| g << 8 \| b;

	image.setRGB(y, rawImage.width - x - 1, value);
	}
	}
	} else {
	// convert raw data to an Image
	image = new BufferedImage(rawImage.width, rawImage.height,
	BufferedImage.TYPE_INT_ARGB);

	byte[] buffer = rawImage.data;
	int index = 0;
	for (int y = 0 ; y < rawImage.height ; y++) {
	for (int x = 0 ; x < rawImage.width ; x++) {

	int value = buffer[index++] & 0x00FF;
	value \|= (buffer[index++] << 8) & 0x0FF00;

	int r = ((value >> 11) & 0x01F) << 3;
	int g = ((value >> 5) & 0x03F) << 2;
	int b = ((value >> 0) & 0x01F) << 3;

	value = 0xFF << 24 \| r << 16 \| g << 8 \| b;

	image.setRGB(x, y, value);
	}
	}
	}

	if (!ImageIO.write(image, "png", new File(filepath))) {
	recordResponse("No png writer", "");
	throw new IOException("Failed to find png writer");
	}
	recordResponse("OK", filepath);
	}

	private static void printUsageAndQuit(String message) {
	// 80 cols marker: 01234567890123456789012345678901234567890123456789012345678901234567890123456789
	System.out.println(message);
	System.out.println("Usage: monkeyrunner [options] SCRIPT_FILE");
	System.out.println("");
	System.out.println(" -s MonkeyServer IP Address.");
	System.out.println(" -p MonkeyServer TCP Port.");
	System.out.println(" -v MonkeyServer Logging level (ALL, FINEST, FINER, FINE, CONFIG, INFO, WARNING, SEVERE, OFF)");
	System.out.println("");
	System.out.println("");

	System.exit(1);
	}

	private static void printAndExit(String message, boolean terminate) {
	System.out.println(message);
	if (terminate) {
	AndroidDebugBridge.terminate();
	}
	System.exit(1);
	}
	}