appium框架之bootstrap-重庆大橙子建站

新闻中心

这里有您想知道的互联网营销解决方案

appium框架之bootstrap

原文地址：http://www.it165.net/pro/html/201407/17696.html

成都创新互联于2013年创立，是专业互联网技术服务公司，拥有项目成都做网站、成都网站制作、成都外贸网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元万源做网站,已为上家服务,为万源各地企业和个人服务,联系电话:18980820575

bootstrap结构

如图所示为bootstrap的项目结构

appium框架之bootstrap

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被执行。

该类很简单，就是启动线程，监听4724端口，该端口与appium通信。

然后走server.listenForever()方法。

SocketServer.java

  view   sourceprint?
/**
*   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

  view   sourceprint?
/**
*   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的异常。

  view   sourceprint?
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秒开始执行一遍上面注册的监听器来检查系统是否存在异常。

  view   sourceprint?
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);

然后启动数据通道，接受客户端发来的数据和返回结果给客户端。

  view   sourceprint?
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 "http://www.it165.net/pro/ydad/" target="_blank" class="keylink">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 "http://www.it165.net/pro/ydad/" target="_blank"class="keylink">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()方法，获取直接的结果。那么该方法的作用就转移到了runCommand()。所以现在就来看runCommand()方法是啥意思啦。
      view   sourceprint?
      01./**
    02.*   When {@link #handleClientData()} has valid data, this method delegates the
    03.*   command.
    04.*
    05.*   @param cmd
    06.*            AndroidCommand
    07.*   @return Result
    08.*/
    09.private String   runCommand(final AndroidCommand   cmd) {
    10.AndroidCommandResult   res;
    11.if (cmd.commandType()   == AndroidCommandType.SHUTDOWN) {
    12.keepListening   = false;
    13.res   = new AndroidCommandResult(WDStatus.SUCCESS, "OK,   shutting down");
    14.} else if (cmd.commandType()   == AndroidCommandType.ACTION) {
    15.try {
    16.res   = executor.execute(cmd);
    17.} catch (final Exception   e) {
    18.res   = new AndroidCommandResult(WDStatus.UNKNOWN_ERROR,   e.getMessage());
    19.}
    20.} else {
    21.//   this code should never be executed, here for future-proofing
    22.res   = new AndroidCommandResult(WDStatus.UNKNOWN_ERROR,
    23."Unknown   command type, could not execute!");
    24.}
    25.return res.toString();
    26.}
    27.}
  
  该方法首先做了判断，判断命令数据哪种类型，主要有关机命令和动作命令，我们主要关注动作命令，因为动作有很多种。所以来关注第一个else if中的AndroidCommandExecutor.execute()方法。主线又转移到了该方法中了，切去瞅一眼。 
AndroidCommandExecutor.java
      view   sourceprint?
      01./**
    02.*   Gets the handler out of the map, and executes the command.
    03.*
    04.*   @param command
    05.*            The {@link AndroidCommand}
    06.*   @return {@link AndroidCommandResult}
    07.*/
    08.public AndroidCommandResult   execute(final AndroidCommand   command) {
    09.try {
    10.Logger.debug("Got   command action: " +   command.action());
    11. 
    12.if (map.containsKey(command.action()))   {
    13.return map.get(command.action()).execute(command);
    14.} else {
    15.return new AndroidCommandResult(WDStatus.UNKNOWN_COMMAND,
    16."Unknown   command: " + command.action());
    17.}
    18.} catch (final JSONException   e) {
    19.Logger.error("Could   not decode action/params of command");
    20.return new AndroidCommandResult(WDStatus.JSON_DECODER_ERROR,
    21."Could   not decode action/params of command, please check format!");
    22.}
    23.}
  
  该方法中终于要执行命令的实体啦 
      view   sourceprint?
      1.if (map.containsKey(command.action()))   {
    2.return map.get(command.action()).execute(command);
    3.} else {
    4.return new AndroidCommandResult(WDStatus.UNKNOWN_COMMAND,
    5."Unknown   command: " + command.action());
    6.}
 
关键是上面这几行代码，调用了map.get(command.action()).execute(command).看来要想弄懂这个命令的意思，肯定得知道map里存放的对象是哪些，那么在该类中找到map的初始化代码:
      view   sourceprint?
      01.static {
    02.map.put("waitForIdle", new WaitForIdle());
    03.map.put("clear", new Clear());
    04.map.put("orientation", new Orientation());
    05.map.put("swipe", new Swipe());
    06.map.put("flick", new Flick());
    07.map.put("drag", new Drag());
    08.map.put("pinch", new Pinch());
    09.map.put("click", new Click());
    10.map.put("touchLongClick", new TouchLongClick());
    11.map.put("touchDown", new TouchDown());
    12.map.put("touchUp", new TouchUp());
    13.map.put("touchMove", new TouchMove());
    14.map.put("getText", new GetText());
    15.map.put("setText", new SetText());
    16.map.put("getName", new GetName());
    17.map.put("getAttribute", new GetAttribute());
    18.map.put("getDeviceSize", new GetDeviceSize());
    19.map.put("scrollTo", new ScrollTo());
    20.map.put("find", new Find());
    21.map.put("getLocation", new GetLocation());
    22.map.put("getSize", new GetSize());
    23.map.put("wake", new Wake());
    24.map.put("pressBack", new PressBack());
    25.map.put("dumpWindowHierarchy", new DumpWindowHierarchy());
    26.map.put("pressKeyCode", new PressKeyCode());
    27.map.put("longPressKeyCode", new LongPressKeyCode());
    28.map.put("takeScreenshot", new TakeScreenshot());
    29.map.put("updateStrings", new UpdateStrings());
    30.map.put("getDataDir", new GetDataDir());
    31.map.put("performMultiPointerGesture", new MultiPointerGesture());
    32.map.put("openNotification", new OpenNotification());
    33.}
  
  豁然开朗，该map是形式的map。value值对应的都是一个个的对象，这些对象都继承与CommandHandler，里面都有execute方法，该方法就是根据命令的不同调用不同的对象来执行相关代码获取结果。从map的定义可以看出，appium可以操作手机的命令还不少，我用过的有scrollTo,updateStrings,getDataDir等，上面还有截图、打开通知栏、按下等还没用过，但通过这些命令你也可以了解appium可以做哪些事。 
继承CommandHandler的对象有很多，我挑一个来讲讲它具体是干嘛的，其他的我以后会挨个讲,就挑click吧。
加入现在传过来的命令后缀是click的话，那么它会调用Click对象的execute方法。
Click.java
      view   sourceprint?
      01.package io.appium.android.bootstrap.handler;
                                                名称栏目：appium框架之bootstrap                                                

                                                文章源于：http://www.cqwzjz.cn/article/gossdh.html
                                            
                                            
                                                
                                                    其他资讯
                                                
                                                
                                                    
                                                        
                                                                c语言宏写函数 c语言宏函数怎么用
                                                            

                                                                go的语言错误处理 go语言错误处理会变吗
                                                            

                                                                php获取二维数组数据库 php获取二维数组数据库内容
                                                            

                                                                腾讯云服务器cos 腾讯云服务器可以干嘛
                                                            

                                                                zblog百度主动推送 百度自动推送工具