ActivityMonitor 类的功能

这个类只是google为了自动测试所添加的一个类，可以说是一个工具类。

下面我们来分析一下这类是如何使用的，

最简单的方式，就是来监听activity启动是否成功，

首先来看我的单元测试文件。

/**
 * Created by xiepengchong on 15/7/26.
 */
public class MainActivityTest extends ActivityInstrumentationTestCase2<MainActivity> {

    private long TIMEOUT_IN_MS = 0;
    private TextView hello;
    private MainActivity activity;
    public MainActivityTest() {
        super(MainActivity.class);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        activity = getActivity();
        hello = (TextView)activity.findViewById(R.id.hello);
    }



    public void testPrecondition(){
        assertNotNull(hello);
    }

    public void testStartActivity(){
        final Button mButton = (Button)activity.findViewById(R.id.button);
        Instrumentation.ActivityMonitor monitor = getInstrumentation().addMonitor(MainActivity2.class.getName(),null,false);

        TouchUtils.clickView(this, mButton);
        MainActivity2 activity2 = (MainActivity2)getInstrumentation().waitForMonitorWithTimeout(monitor,TIMEOUT_IN_MS);
        assertNotNull("MainActivity2 is Null",activity2);
        getInstrumentation().removeMonitor(monitor);

    }

    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
    }
}

这是来启动点击事件来启动Activity的，activity2既是启动的Activity，

那么这个事如何能够做到监听的呢，其实这个主要还是Instrumentation所起的作用，

通过看我的上一篇博客可以看到Activity启动流程

    private void postPerformCreate(Activity activity) {
        if (mActivityMonitors != null) {
            synchronized (mSync) {
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    am.match(activity, activity, activity.getIntent());
                }
            }
        }
    }
可以看到这里来遍历Monitor的List，PS（这个list就是我们在addMonitor中添加的）

然后回调用match方法

        final boolean match(Context who,
                            Activity activity,
                            Intent intent) {
            synchronized (this) {
                if (mWhich != null
                    && mWhich.match(who.getContentResolver(), intent,
                                    true, "Instrumentation") < 0) {
                    return false;
                }
                if (mClass != null) {
                    String cls = null;
                    if (activity != null) {
                        cls = activity.getClass().getName();
                    } else if (intent.getComponent() != null) {
                        cls = intent.getComponent().getClassName();
                    }
                    if (cls == null || !mClass.equals(cls)) {
                        return false;
                    }
                }
                if (activity != null) {
                    mLastActivity = activity;
                    notifyAll();
                }
                return true;
            }
        }
    }
这里会将mLastActivity赋值了，

然后在

public Activity waitForMonitorWithTimeout(ActivityMonitor monitor, long timeOut) {
        Activity activity = monitor.waitForActivityWithTimeout(timeOut);
        synchronized (mSync) {
            mActivityMonitors.remove(monitor);
        }
        return activity;
    }

  public final Activity waitForActivityWithTimeout(long timeOut) {
            synchronized (this) {
                if (mLastActivity == null) {
                    try {
                        wait(timeOut);
                    } catch (InterruptedException e) {
                    }
                }
                if (mLastActivity == null) {
                    return null;
                } else {
                    Activity res = mLastActivity;
                    mLastActivity = null;
                    return res;
                }
            }
        }
这里可以看到会判断mLastActivity的值，也就是我们刚刚启动Activity时赋值的，