CTS 设备管理之自动检测设备

一纸荒年

经过三个月的蹉跎，项目终于可以推出1.0版本。中间经历过很多坑，中途我们的主程离职走了，我硬着头皮
接替了他的工作，从cts框架的启动开始，一点一点地研究源码，debug来debug去，一点一点的理解其中的
思想，到现在已经能在cts的框架的基础上做二次开发，能简单的认识到cts处理方式。很有幸我一进入自动化
领域首先认识的是cts这套框架，随着研究的深入越来越佩服开发这套框架的google工程师们。我想说的是，
做自动化框架开发的人都应该好好研究这个框架，肯定会受益匪浅。其实在学习的时候，我就已经写过好几
篇文章，我也将其整理成合集，放到了testerhome上。但那个时候毕竟还是懵懂时期，也没有跳出框架从全
局来考虑，现在刚好有点时间，慢慢的把这几个月的研究成果总结一下。

设备管理的重要性

做Android自动化工具开发的都了解，你首先要解决的问题是设备管理问题，在支持 Mult Device的工具中尤
其重要。新设备的加入、已有设备的断线离线，在执行case的过程中遇到设备离线了如何去恢复等等，都是
在设备管理范畴之内的。那么cts是如何做到的？

1.包裹ADB

1. 
   
2. package com.android.tradefed.device;
   
3. 
   
4. import com.android.ddmlib.AndroidDebugBridge;
   
5. import com.android.ddmlib.AndroidDebugBridge.IDeviceChangeListener;
   
6. import com.android.ddmlib.IDevice;
   
7. 
   
8. /**
   
9. * A wrapper that directs {@link IAndroidDebugBridge} calls to the 'real'
   
10. * {@link AndroidDebugBridge}.
    
11. */
    
12. class AndroidDebugBridgeWrapper implements IAndroidDebugBridge {
    
13. 
    
14.     private AndroidDebugBridge mAdbBridge = null;
    
15. 
    
16.     /**
    
17.      * Creates a {@link AndroidDebugBridgeWrapper}.
    
18.      */
    
19.     AndroidDebugBridgeWrapper() {
    
20.     }
    
21. 
    
22.     /**
    
23.      * {@inheritDoc}
    
24.      */
    
25.     @Override
    
26.     public IDevice[] getDevices() {
    
27.         if (mAdbBridge == null) {
    
28.             throw new IllegalStateException("getDevices called before init");
    
29.         }
    
30.         return mAdbBridge.getDevices();
    
31.     }
    
32. 
    
33.     /**
    
34.      * {@inheritDoc}
    
35.      */
    
36.     @Override
    
37.     public void addDeviceChangeListener(IDeviceChangeListener listener) {
    
38.         AndroidDebugBridge.addDeviceChangeListener(listener);
    
39.     }
    
40. 
    
41.     /**
    
42.      * {@inheritDoc}
    
43.      */
    
44.     @Override
    
45.     public void removeDeviceChangeListener(IDeviceChangeListener listener) {
    
46.         AndroidDebugBridge.removeDeviceChangeListener(listener);
    
47.     }
    
48. 
    
49.     /**
    
50.      * {@inheritDoc}
    
51.      */
    
52.     @Override
    
53.     public void init(boolean clientSupport, String adbOsLocation) {
    
54.         AndroidDebugBridge.init(clientSupport);
    
55.         mAdbBridge = AndroidDebugBridge.createBridge(adbOsLocation, false);
    
56.     }
    
57. 
    
58.     /**
    
59.      * {@inheritDoc}
    
60.      */
    
61.     @Override
    
62.     public void terminate() {
    
63.         AndroidDebugBridge.terminate();
    
64.     }
    
65. 
    
66.     /**
    
67.      * {@inheritDoc}
    
68.      */
    
69.     @Override
    
70.     public void disconnectBridge() {
    
71.         AndroidDebugBridge.disconnectBridge();
    
72.     }
    
73. }

复制代码

这里实际上用到了代理模式。cts中自定义的类AndroidDebugBridgeWrapper包裹了AndroidDebugBridge，
我们只需要和AndroidDebugBridgeWrapper交互就行了。然后在AndroidDebugBridge的基础上自定义了一
些方法。继承的方法中重要的是addDeviceChangeListener和removeDeviceChangeListener这两个方法，
待会我们就要用到。

2.启动ADB

1. 
   
2. public class DeviceManager implements IDeviceManager {
   
3. 
   
4.     ......
   
5.     private IAndroidDebugBridge mAdbBridge;
   
6.     private ManagedDeviceListener mManagedDeviceListener;
   
7.     ......
   
8.     /**
   
9.      * The DeviceManager should be retrieved from the {@link GlobalConfiguration}
   
10.      */
    
11.     public DeviceManager() {
    
12.     }
    
13. 
    
14.     /**
    
15.      * Initialize the device manager. This must be called once and only once before any other
    
16.      * methods are called.
    
17.      */
    
18.     synchronized void init(IDeviceSelection globalDeviceFilter,
    
19.             List<IDeviceMonitor> globalDeviceMonitors, IManagedTestDeviceFactory deviceFactory) {
    
20.         ......
    
21.         mAdbBridge = createAdbBridge();
    
22.         mManagedDeviceListener = new ManagedDeviceListener();
    
23.         ......
    
24.         mAdbBridge.addDeviceChangeListener(mManagedDeviceListener);
    
25.        ......
    
26.         mAdbBridge.init(false /* client support */, "adb");
    
27.         ......
    
28.     }
    
29.     /**
    
30.      * Creates the {@link IAndroidDebugBridge} to use.
    
31.      * <p/>
    
32.      * Exposed so tests can mock this.
    
33.      * @returns the {@link IAndroidDebugBridge}
    
34.      */
    
35.     synchronized IAndroidDebugBridge createAdbBridge() {
    
36.         return new AndroidDebugBridgeWrapper();
    
37.     }
    
38. }
    

复制代码

在DeviceManage类的init方法中，首先通过createAdbBridge()方法创建一个 IAndroidDebugBridge对象，其
实质是刚才定义的AndroidDebugBridgeWrapper对象。这样的话我们就得到了该对象的一个实例，接着我
们调用了该实例的init方法(其实有2行代码我故意忽略了，后面会隆重登场)，这样ADB的初始化工作就完成了。

3.状态监听器

1. private class ManagedDeviceListener implements IDeviceChangeListener {
   
2. 
   
3.         /**
   
4.          * {@inheritDoc}
   
5.          */
   
6.         @Override
   
7.         public void deviceChanged(IDevice idevice, int changeMask) {   
   
8.         ......
   
9.         }
   
10. 
    
11.         /**
    
12.          * {@inheritDoc}
    
13.          */
    
14.         @Override
    
15.         public void deviceConnected(IDevice idevice) {  
    
16.         ......        
    
17.         }
    
18. 
    
19.         /**
    
20.          * {@inheritDoc}
    
21.          */
    
22.         @Override
    
23.         public void deviceDisconnected(IDevice disconnectedDevice) {
    
24.          ......
    
25.         }
    
26.     }

复制代码

在DeviceManager类中定义了一个私有类ManagedDeviceListener，该类实现了ADB中的接口IDeviceChangeL
istener。该接口实际上是观察者模式中的一个抽象观察者，我们定义的ManagedDeviceListener类是一个具
体观察者。当我们注册为设备状态的观察者后，设备状态发生变化后，我们会被通知到。这个时候我们隆
重请出刚才我们忽略的2行代码：

mManagedDeviceListener = new ManagedDeviceListener();
......
mAdbBridge.addDeviceChangeListener(mManagedDeviceListener);
这两行代码首先初始化了一个设备状态的具体观察者对象的实例，然后将其添加到通知列表中，这个时候
ADB设备发生改变后，就会通知我们的对象，其中相应的三个方法deviceChanged,deviceConnected,devic
eDisconnected会被调用，这个时候我们就可以通过一些处理得到新加入的设备，或者已有设备中离线的
设备，然后将其删除。这样我们就能很好的监听着设备状态的改变。

4.得到设备

既然我们能准确的监听着设备状态的改变，我们就要用一个(或许是多个)容器去保存这些设备。具体的操
作流程我觉得单独写一篇文章来讲比较好，这样才能对得起它良好的设计。