appium框架之bootstrap

(閑來無事。做做測試..)近期弄了弄appium，感覺挺有意思。就深入研究了下。

看小弟這篇文章之前，先了解一下appium的架構，對你理解有優點，推薦以下這篇文章：testerhome

appium是開源項目。能夠獲得源代碼：appium-master

在eclipse中用maven導入會發現有2個項目：bootstrap和sauce_appium_junit。

sauce_appium_junit是一些測試用例的集合。幫助學習的。

bootstrap就是appium架構中放在手機端的一個server。就從它開始吧。

bootstrap結構

如圖所看到的為bootstrap的項目結構

bootstrap作用

bootstrap在appium中是以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);
    }

  }
}

該類繼承自UiAutomatorTestCase。

所以它才干通過adb shell uiautomator runtest AppiumBootstrap.jar -c io.appium.android.bootstrap.Bootstrap被運行。

該類非常easy，就是啟動線程，監聽4724port。該port與appium通信。

然后走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發來的數據和返回結果給client。

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() + ")");
    }
  }

該方法中讀取client發來的數據，利用getCommand()方法獲得AndroidCommand對象。然后運行runCommand()方法，獲取直接的結果。那么該方法的作用就轉移到了runCommand()。

所以如今就來看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里存放的對象是哪些，那么在該類中找到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能夠操作手機的命令還不少，我用過的有scrollTo,updateStrings,getDataDir等。上面還有截圖、打開通知欄、按下等還沒用過。但通過這些命令你也能夠了解appium能夠做哪些事。

繼承CommandHandler的對象有非常多，我挑一個來講講它詳細是干嘛的。其它的我以后會挨個講,就挑click吧。

增加如今傳過來的命令后綴是click的話。那么它會調用Click對象的execute方法。

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);
    }
  }
}

該類就一個execute方法這根獨苗，execute方法中會先推斷傳入的參數對象是坐標值還是元素值，假設是元素值那么直接調用AndroidElement中的click方法，一會我們再去看這種方法。假設是坐標的話，它會干什么呢。

它會調用UiDevice的click方法，用過UiAutomator的人都知道它是uiautomator包中的類。

所以說appium在api16以上的機器上使用的uiautomator機制。貌似有人認為這好像easy了點。那好吧，我們再分析一個touchDown命令，假設傳過來的命令后綴是touchDown，那么它會調用TouchDown對象的execute方法。

map.put("touchDown", new TouchDown());

這個類里面的execute方法就有點意思啦。

TouchDown.java

package io.appium.android.bootstrap.handler;

import com.android.uiautomator.common.ReflectionUtils;
import com.android.uiautomator.core.UiObjectNotFoundException;
import io.appium.android.bootstrap.Logger;

import java.lang.reflect.Method;

/**
 * This handler is used to perform a touchDown event on an element in the
 * Android UI.
 * 
 */
public class TouchDown extends TouchEvent {

  @Override
  protected boolean executeTouchEvent() throws UiObjectNotFoundException {
    printEventDebugLine("TouchDown");
    try {
      final ReflectionUtils utils = new ReflectionUtils();
      final Method touchDown = utils.getControllerMethod("touchDown", int.class,
          int.class);
      return (Boolean) touchDown.invoke(utils.getController(), clickX, clickY);
    } catch (final Exception e) {
      Logger.debug("Problem invoking touchDown: " + e);
      return false;
    }
  }
}

該方法里用到了反射，調用uiautomator里的隱藏api來運行按下操作。就不詳細講了。后面會挨個說一遍的。

總結

說了這么多廢話，嘗試着用序列圖描寫敘述一遍吧。