手机自动化测试：appium源码分析之bootstrap 1

手机自动化测试：appium源码分析之bootstrap一

      前言：

       poptest是国内唯一一家培养测试开发工程师的培训机构，以学员能胜任自动化测试，性能测试，测试工具开发等工作为目标。poptest推出手机自动化测试的课程，讲解appuim的实际应用，培训全程用商业项目，   大家可以加qq群进行交流：195983133

 

       开源的项目最大的好处是可以获得源代码，我们可以在源代码的基础上进行修改代码，编译，开发出符合我们要求的项目。如果想要做到可以修改源代码，首先要读懂代码了解代码。国内的一些公司就是在开源的软件基础上进行了二次开发封装，然后打出自己的logo，在销售给客户。一些互联网公司也的产品代码中也用了好多开源的代码。那么我们来看看appium的代码是什么样的。         

 

     准备：

 appium是开源项目，可以获得源码：appium-master，在eclipse中用maven导入出现2个项目：bootstrap和sauce_appium_junit。
 sauce_appium_junit是测试用例集合，帮助学习，如果有时间可以好好读读。bootstrap是appium运行在手机端的服务器。

     开始 

一.bootstrap作用
bootstrap以jar包形式存在，实际上是uiautomator写的case包，通过PC端的命令在手机端执行。

二.bootstrap源码分析
程序入口是Bootstrap类
下面是Bootstrap.java源码

package io.appium.android.bootstrap;

import io.appium.android.bootstrap.exceptions.SocketServerException;

import com.android.uiautomator.testrunner.UiAutomatorTestCase;

/**
 * The Bootstrap class runs the socket server. uiautomator开发的脚本，可以直接在pc端启动
 */
public class Bootstrap extends UiAutomatorTestCase {

  public void testRunServer() {
    SocketServer server;
    try {
      // 启动socket服务器，监听4724端口。
      server = new SocketServer(4724);
      server.listenForever();
    } catch (final SocketServerException e) {
      Logger.error(e.getError());
      System.exit(1);
    }

  }
}

该类是启动线程，监听4724端口，通过该端口与appium通信。该类继承自UiAutomatorTestCase。pc端通过adb发送指令adb shell uiautomator runtest AppiumBootstrap.jar -c ，io.appium.android.bootstrap.Bootstrap执行。

然后执行server.listenForever()方法
请看SocketServer.java源码

/**
   * Listens on the socket for data, and calls {@link #handleClientData()} when
   * it's available.
   * 
   * @throws SocketServerException
   */
  public void listenForever() throws SocketServerException {
    Logger.debug("Appium Socket Server Ready");
    //读取strings.json文件的数据
    UpdateStrings.loadStringsJson();
    // 注册两种监听器：AND和Crash
    dismissCrashAlerts();
    final TimerTask updateWatchers = new TimerTask() {
      @Override
      public void run() {
        try {
          // 检查系统是否有异常
          watchers.check();
        } catch (final Exception e) {
        }
      }
    };
    // 计时器，0.1秒后开始，每隔0.1秒执行一次。
    timer.scheduleAtFixedRate(updateWatchers, 100, 100);

    try {
      client = server.accept();
      Logger.debug("Client connected");
      in = new BufferedReader(new InputStreamReader(client.getInputStream(),
          "UTF-8"));
      out = new BufferedWriter(new OutputStreamWriter(client.getOutputStream(),
          "UTF-8"));
      while (keepListening) {
        // 获取客户端数据
        handleClientData();
      }
      in.close();
      out.close();
      client.close();
      Logger.debug("Closed client connection");
    } catch (final IOException e) {
      throw new SocketServerException("Error when client was trying to connect");
    }
  }
该方法中调用UpdateStrings.loadStringsJson();代码如下（UpdateStrings）:

/**
   * strings.json文件保存的是apk的strings.xml里的内容，在Bootstrap启动前由appium服务器解析并push到设备端的
   * 
   * @return
   */
  public static boolean loadStringsJson() {
    Logger.debug("Loading json...");
    try {
      final String filePath = "/data/local/tmp/strings.json";
      final File jsonFile = new File(filePath);
      // json will not exist for apks that are only on device
      // 你的case必须写明apk的路径，如果启动设备上已有的应用而case中没有app路径，此时json文件是不存在的
      // because the node server can't extract the json from the apk.
      if (!jsonFile.exists()) {
        return false;
      }
      final DataInputStream dataInput = new DataInputStream(
          new FileInputStream(jsonFile));
      final byte[] jsonBytes = new byte[(int) jsonFile.length()];
      dataInput.readFully(jsonBytes);
      // this closes FileInputStream
      dataInput.close();
      final String jsonString = new String(jsonBytes, "UTF-8");
      // 将读取出来的信息赋给Find类中的属性，以做后用
      Find.apkStrings = new JSONObject(jsonString);
      Logger.debug("json loading complete.");
    } catch (final Exception e) {
      Logger.error("Error loading json: " + e.getMessage());
      return false;
    }
    return true;
  }
执行后返回到ServerSocket类的listenForever()，执行到dismissCrashAlerts();该方法是注册监听器，观察是否有弹出框或者AND和crash异常。

public void dismissCrashAlerts() {
    try {
      new UiWatchers().registerAnrAndCrashWatchers();
      Logger.debug("Registered crash watchers.");
    } catch (final Exception e) {
      Logger.debug("Unable to register crash watchers.");
    }
  }
listenForever()方法执行到注册心跳程序，每隔0.1秒开始执行一遍上面注册的监听器来检查系统是否存在异常。

final TimerTask updateWatchers = new TimerTask() {
      @Override
      public void run() {
        try {
          // 检查系统是否有异常
          watchers.check();
        } catch (final Exception e) {
        }
      }
    };
    // 计时器，0.1秒后开始，每隔0.1秒执行一次。
    timer.scheduleAtFixedRate(updateWatchers, 100, 100);
然后启动数据通道，接受客户端发来的数据和返回结果给客户端。

client = server.accept();
      Logger.debug("Client connected");
      in = new BufferedReader(new InputStreamReader(client.getInputStream(),
          "UTF-8"));
      out = new BufferedWriter(new OutputStreamWriter(client.getOutputStream(),
          "UTF-8"));
接下来是handleClientData()方法;到此listenForever()的作用完成。handleClientData()方法代码如下。

/**
   * When data is available on the socket, this method is called to run the
   * command or throw an error if it can't.
   * 
   * @throws SocketServerException
   */
  private void handleClientData() throws SocketServerException {
    try {
      input.setLength(0); // clear

      String res;
      int a;
      // (char) -1 is not equal to -1.
      // ready is checked to ensure the read call doesn't block.
      while ((a = in.read()) != -1 && in.ready()) {
        input.append((char) a);
      }
      final String inputString = input.toString();
      Logger.debug("Got data from client: " + inputString);
      try {
        final AndroidCommand cmd = getCommand(inputString);
        Logger.debug("Got command of type " + cmd.commandType().toString());
        res = runCommand(cmd);
        Logger.debug("Returning result: " + res);
      } catch (final CommandTypeException e) {
        res = new AndroidCommandResult(WDStatus.UNKNOWN_ERROR, e.getMessage())
            .toString();
      } catch (final JSONException e) {
        res = new AndroidCommandResult(WDStatus.UNKNOWN_ERROR,
            "Error running and parsing command").toString();
      }
      out.write(res);
      out.flush();
    } catch (final IOException e) {
      throw new SocketServerException("Error processing data to/from socket ("
          + e.toString() + ")");
    }
  }

该方法接收客户端数据，用getCommand()方法获得AndroidCommand对象，然后执行runCommand()方法，获取结果。

/**

   * When {@link #handleClientData()} has valid data, this method delegates the
   * command.
   * 
   * @param cmd
   *          AndroidCommand
   * @return Result
   */
  private String runCommand(final AndroidCommand cmd) {
    AndroidCommandResult res;
    if (cmd.commandType() == AndroidCommandType.SHUTDOWN) {
      keepListening = false;
      res = new AndroidCommandResult(WDStatus.SUCCESS, "OK, shutting down");
    } else if (cmd.commandType() == AndroidCommandType.ACTION) {
      try {
        res = executor.execute(cmd);
      } catch (final Exception e) {
        res = new AndroidCommandResult(WDStatus.UNKNOWN_ERROR, e.getMessage());
      }
    } else {
      // this code should never be executed, here for future-proofing
      res = new AndroidCommandResult(WDStatus.UNKNOWN_ERROR,
          "Unknown command type, could not execute!");
    }
    return res.toString();
  }
}

该方法判断命令数据属于哪种类型，命令有关机命令和动作命令，关注动作动作有很多。重点要看第一个else if中的AndroidCommandExecutor.execute()方法。AndroidCommandExecutor.java

/**
   * Gets the handler out of the map, and executes the command.
   *
   * @param command
   *          The {@link AndroidCommand}
   * @return {@link AndroidCommandResult}
   */
  public AndroidCommandResult execute(final AndroidCommand command) {
    try {
      Logger.debug("Got command action: " + command.action());

      if (map.containsKey(command.action())) {
        return map.get(command.action()).execute(command);
      } else {
        return new AndroidCommandResult(WDStatus.UNKNOWN_COMMAND,
            "Unknown command: " + command.action());
      }
    } catch (final JSONException e) {
      Logger.error("Could not decode action/params of command");
      return new AndroidCommandResult(WDStatus.JSON_DECODER_ERROR,
          "Could not decode action/params of command, please check format!");
    }
  }
该命令执行后，开始执行你的所有操作内容了

if (map.containsKey(command.action())) {
        return map.get(command.action()).execute(command);
      } else {
        return new AndroidCommandResult(WDStatus.UNKNOWN_COMMAND,
            "Unknown command: " + command.action());
      }
请注意map.get(command.action()).execute(command).在该类中找到map的代码:

static {
    map.put("waitForIdle", new WaitForIdle());
    map.put("clear", new Clear());
    map.put("orientation", new Orientation());
    map.put("swipe", new Swipe());
    map.put("flick", new Flick());
    map.put("drag", new Drag());
    map.put("pinch", new Pinch());
    map.put("click", new Click());
    map.put("touchLongClick", new TouchLongClick());
    map.put("touchDown", new TouchDown());
    map.put("touchUp", new TouchUp());
    map.put("touchMove", new TouchMove());
    map.put("getText", new GetText());
    map.put("setText", new SetText());
    map.put("getName", new GetName());
    map.put("getAttribute", new GetAttribute());
    map.put("getDeviceSize", new GetDeviceSize());
    map.put("scrollTo", new ScrollTo());
    map.put("find", new Find());
    map.put("getLocation", new GetLocation());
    map.put("getSize", new GetSize());
    map.put("wake", new Wake());
    map.put("pressBack", new PressBack());
    map.put("dumpWindowHierarchy", new DumpWindowHierarchy());
    map.put("pressKeyCode", new PressKeyCode());
    map.put("longPressKeyCode", new LongPressKeyCode());
    map.put("takeScreenshot", new TakeScreenshot());
    map.put("updateStrings", new UpdateStrings());
    map.put("getDataDir", new GetDataDir());
    map.put("performMultiPointerGesture", new MultiPointerGesture());
    map.put("openNotification", new OpenNotification());
  }
map是<String,CommandHandler>形式的map。value值对应的都是对象，这些对象继承自CommandHandler，都有execute方法，该方法就是根据命令的不同调用不同的对象来执行相关代码获取结果。从map的定义可以看出，appium手机的命令很丰富，我们可以在这里加入我们需要的操作代码、

  我们来看看click方法，研究下（Click.java）。

package io.appium.android.bootstrap.handler;

import com.android.uiautomator.core.UiDevice;
import com.android.uiautomator.core.UiObjectNotFoundException;
import io.appium.android.bootstrap.*;
import org.json.JSONException;

import java.util.ArrayList;
import java.util.Hashtable;

/**
 * This handler is used to click elements in the Android UI.
 * 
 * Based on the element Id, click that element.
 * 
 */
public class Click extends CommandHandler {

  /*
   * @param command The {@link AndroidCommand}
   * 
   * @return {@link AndroidCommandResult}
   * 
   * @throws JSONException
   * 
   * @see io.appium.android.bootstrap.CommandHandler#execute(io.appium.android.
   * bootstrap.AndroidCommand)
   */
  @Override
  public AndroidCommandResult execute(final AndroidCommand command)
      throws JSONException {
    if (command.isElementCommand()) {
      try {
        final AndroidElement el = command.getElement();
        el.click();
        return getSuccessResult(true);
      } catch (final UiObjectNotFoundException e) {
        return new AndroidCommandResult(WDStatus.NO_SUCH_ELEMENT,
            e.getMessage());
      } catch (final Exception e) { // handle NullPointerException
        return getErrorResult("Unknown error");
      }
    } else {
      final Hashtable<String, Object> params = command.params();
      final Double[] coords = { Double.parseDouble(params.get("x").toString()),
          Double.parseDouble(params.get("y").toString()) };
      final ArrayList<Integer> posVals = absPosFromCoords(coords);
      final boolean res = UiDevice.getInstance().click(posVals.get(0),
          posVals.get(1));
      return getSuccessResult(res);
    }
  }
}