tools/monkeyrunner/src/com/android/monkeyrunner/MonkeyRecorder.java

/*
 * 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 java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.jheer.XMLWriter;

/**
 *  MonkeyRecorder is a host side class that records the output of scripts that are run. 
 *  It creates a unique directory, puts in an xml file that records each cmd and result.
 *  It stores every screenshot in this directory.
 *  When finished, it zips this all up.
 *
 *  Calling Sequence:
 *    mr = new MonkeyRecorder(scriptName);
 *    mr.startCommand();
 *    [mr.addAttribute(name, value);]
 *    ...
 *    [mr.addInput(cmd);]
 *    [mr.addResults(result, filename);]   // filename = "" if no screenshot
 *    mr.endCommand();
 *    mr.addComment(comment);
 *    mr.startCommand();
 *    ...
 *    mr.endCommand();
 *    ...
 *    mr.close();
 *
 *  With MonkeyRunner this should output an xml file, <script_name>-yyyyMMdd-HH:mm:ss.xml, into the
 *  directory out/<script_name>-yyyyMMdd-HH:mm:ss with the contents:
 *
 *  <?xml version="1.0" encoding='UTF-8'?>
 *  <script_run>
 *    script_name="filename"
 *    monkeyRunnerVersion="0.2"
 *    <!-- Device specific variables -->
 *    <device_var var_name="name" var_value="value" />
 *    <device_var name="build.display" value="opal-userdebug 1.6 DRC79 14207 test-keys"/>
 *    ...
 *    <!-- Script commands -->
 *    <command>
 *      dateTime="20090921-17:08:43"
 *      <input cmd="Pressing: menu"/>
 *      <response result="OK" dateTime="20090921-17:08:43"/>
 *    </command>
 *    ...
 *    <command>
 *      dateTime="20090921-17:09:44"
 *      <input cmd="grabscreen"/>
 *      <response result="OK" dateTime="20090921-17:09:45" screenshot="home_screen-20090921-17:09:45.png"/>
 *    </command>
 *    ...
 *  </script_run>
 *  
 *  And then zip it up with all the screenshots in the file: <script_name>-yyyyMMdd-HH:mm:ss.zip.
 */
 
public class MonkeyRecorder {

  // xml file to store output results in
  private static String mXmlFilename;
  private static FileWriter mXmlFile;
  private static XMLWriter mXmlWriter;
  
  // unique subdirectory to put results in (screenshots and xml file)
  private static String mDirname;
  private static List<String> mScreenShotNames = new ArrayList<String>();
  
  // where we store all the results for all the script runs
  private static final String ROOT_DIR = "out";
  
  // for getting the date and time in now()
  private static final SimpleDateFormat SIMPLE_DATE_TIME_FORMAT = new SimpleDateFormat("yyyyMMdd-HH:mm:ss");
  
  /**
   * Create a new MonkeyRecorder that records commands and zips up screenshots for submittal
   * 
   * @param scriptName filepath of the monkey script we are running
   */
  public MonkeyRecorder(String scriptName) throws IOException {
    // Create directory structure to store xml file, images and zips
    File scriptFile = new File(scriptName);
    scriptName = scriptFile.getName();  // Get rid of path
    mDirname = ROOT_DIR + "/" + stripType(scriptName) + "-" + now();
    new File(mDirname).mkdirs();
    
    // Initialize xml file
    mXmlFilename = stampFilename(stripType(scriptName) + ".xml");
    initXmlFile(scriptName);
  }

  // Get the current date and time in a simple string format (used for timestamping filenames)
  private static String now() {
    return SIMPLE_DATE_TIME_FORMAT.format(Calendar.getInstance().getTime());     
  }
  
  /**
   * Initialize the xml file writer
   * 
   * @param scriptName filename (not path) of the monkey script, stored as attribute in the xml file
   */
  private static void initXmlFile(String scriptName) throws IOException {
    mXmlFile = new FileWriter(mDirname + "/" + mXmlFilename);
    mXmlWriter = new XMLWriter(mXmlFile);
    mXmlWriter.begin();
    mXmlWriter.comment("Monkey Script Results");
    mXmlWriter.start("script_run");
    mXmlWriter.addAttribute("script_name", scriptName);
  }
  
  /**
   * Add a comment to the xml file.
   * 
   * @param comment comment to add to the xml file
   */
  public static void addComment(String comment) throws IOException {
    mXmlWriter.comment(comment);
  }
    
  /**
   * Begin writing a command xml element
   */
  public static void startCommand() throws IOException {
    mXmlWriter.start("command");
    mXmlWriter.addAttribute("dateTime", now());
  }
  
  /**
   * Write a command name attribute in a command xml element.  
   * It's add as a sinlge script command could be multiple monkey commands.
   * 
   * @param cmd command sent to the monkey
   */
  public static void addInput(String cmd)  throws IOException {
    String name = "cmd";
    String value = cmd;
    mXmlWriter.tag("input", name, value);
  }
  
  /**
   * Write a response xml element in a command.  
   * Attributes include the monkey result, datetime, and possibly screenshot filename
   * 
   * @param result response of the monkey to the command
   * @param filename filename of the screen shot (or other file to be included)
   */
  public static void addResult(String result, String filename) throws IOException {
    int num_args = 2;
    String[] names = new String[3];
    String[] values = new String[3];
    names[0] = "result";
    values[0] = result;
    names[1] = "dateTime";
    values[1] = now();
    if (filename.length() != 0) {
      names[2] = "screenshot";
      values[2] = stampFilename(filename); 
      addScreenShot(filename);
      num_args = 3;
    }
    mXmlWriter.tag("response", names, values, num_args); 
  }
  
  /**
   * Add an attribut to an xml element. name="escaped_value"
   * 
   * @param name name of the attribute
   * @param value value of the attribute
   */
  public static void addAttribute(String name, String value) throws IOException {
    mXmlWriter.addAttribute(name, value);
  }

   /**
   * Add an xml device variable element. name="escaped_value"
   * 
   * @param name name of the variable
   * @param value value of the variable
   */
  public static void addDeviceVar(String name, String value) throws IOException {
    String[] names = {"name", "value"};
    String[] values = {name, value};
    mXmlWriter.tag("device_var", names, values, names.length);
  }
 
  /**
   * Move the screenshot to storage and remember you did it so it can be zipped up later.
   * 
   * @param filename file name of the screenshot to be stored (Not path name)
   */
  private static void addScreenShot(String filename) {
    File file = new File(filename);
    String screenShotName = stampFilename(filename);
    file.renameTo(new File(mDirname, screenShotName));
    mScreenShotNames.add(screenShotName);
  }

  /**
   * Finish writing a command xml element
   */
  public static void endCommand() throws IOException {
    mXmlWriter.end();
  }
  
  /**
   * Add datetime in front of filetype (the stuff after and including the last infamous '.')
   *
   * @param filename path of file to be stamped
   */
  private static String stampFilename(String filename) {
    // 
    int typeIndex = filename.lastIndexOf('.');
    if (typeIndex == -1) {
      return filename + "-" + now();
    }  
    return filename.substring(0, typeIndex) + "-" + now() + filename.substring(typeIndex);
  }
  
  /**
   * Strip out the file type (the stuff after and including the last infamous '.')
   *
   * @param filename path of file to be stripped of type information
   */
   private static String stripType(String filename) {
    // 
    int typeIndex = filename.lastIndexOf('.');
    if (typeIndex == -1)
      return filename;
    return filename.substring(0, typeIndex);
  }
  
   /**
   * Add a signature element
   *
   * @param filename path of file to be signatured
   */
   private static void addMD5Signature(String filename) throws IOException {
      String signature = "";
      // find signature... MD5 sig = new MD5(filename); signature = sig.toString();
      String[] names = new String[] { "type", "filename", "signature" };
      String[] values = new String[] { "md5", filename, signature };
      mXmlWriter.tag("Signature", names, values, values.length);
   }
 

  /**
   * Close the monkeyRecorder by closing the xml file and zipping it up with the screenshots.
   *
   * @param filename path of file to be stripped of type information
   */ 
  public static void close() throws IOException {
    // zip up xml file and screenshots into ROOT_DIR.
    byte[] buf = new byte[1024];
    String zipFileName = mXmlFilename + ".zip";
    endCommand();
    mXmlFile.close();
    FileOutputStream zipFile = new FileOutputStream(ROOT_DIR + "/" + zipFileName);
    ZipOutputStream out = new ZipOutputStream(zipFile);

    // add the xml file
    addFileToZip(out, mDirname + "/" + mXmlFilename, buf);
    
    // Add the screenshots
    for (String filename : mScreenShotNames) {
      addFileToZip(out, mDirname + "/" + filename, buf);
    }
    out.close();
  }
  
  /**
   * Helper function to zip up a file into an open zip archive.
   *
   * @param zip the stream of the zip archive
   * @param filepath the filepath of the file to be added to the zip archive
   * @param buf storage place to stage reads of file before zipping
   */ 
  private static void addFileToZip(ZipOutputStream zip, String filepath, byte[] buf) throws IOException {
    FileInputStream in = new FileInputStream(filepath);
    zip.putNextEntry(new ZipEntry(filepath));
    int len;
    while ((len = in.read(buf)) > 0) {
      zip.write(buf, 0, len);
    }
    zip.closeEntry();
    in.close();
  }
}