Espresso在AsyncTask执行期间截取屏幕的实现问题

首先得明确：你当前的代码方式并不正确，核心问题出在截图时机的控制上——点击启动按钮后立刻调用runOnUiThread截图，要么AsyncTask还没运行到你想要捕捉的UI状态，要么Espresso的默认等待机制会阻塞测试线程，直到AsyncTask完全结束才执行截图，最终得到的是任务完成后的画面，而非运行中的状态。

下面给你两种可靠的解决思路，按需选择：

方案1：精准控制截图时机（推荐，稳定可靠） #

如果只是想在AsyncTask运行到某个特定阶段（比如进度更新到50%、加载弹窗显示时）截图，最稳妥的方式是给AsyncTask添加回调通知，让测试代码在收到信号后再执行截图操作。

步骤1：在被测代码的AsyncTask中添加回调接口 #

public class MyLoadingTask extends AsyncTask<Void, Integer, Void> {
    // 定义进度回调接口
    public interface OnTaskProgressListener {
        void onReachTargetState();
    }

    private OnTaskProgressListener mProgressListener;

    public void setProgressListener(OnTaskProgressListener listener) {
        mProgressListener = listener;
    }

    @Override
    protected Void doInBackground(Void... voids) {
        // 模拟任务执行过程
        for (int i = 0; i < 100; i++) {
            publishProgress(i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        // 当任务运行到你想截图的状态时（比如进度到50%），发送通知
        if (mProgressListener != null && values[0] == 50) {
            mProgressListener.onReachTargetState();
        }
    }
}

步骤2：在测试代码中监听回调并截图 #

@Test
public void captureScreenshotDuringTask() throws InterruptedException {
    final CountDownLatch latch = new CountDownLatch(1);
    
    // 获取Activity中的AsyncTask实例并设置回调
    MyLoadingTask task = (MyLoadingTask) mActivityTestRule.getActivity().getCurrentTask();
    task.setProgressListener(new MyLoadingTask.OnTaskProgressListener() {
        @Override
        public void onReachTargetState() {
            latch.countDown(); // 收到通知后释放锁
        }
    });

    // 启动异步任务
    onView(withId(R.id.start_task_button)).perform(click());
    
    // 等待直到任务运行到目标状态（最多等待5秒，避免无限阻塞）
    latch.await(5, TimeUnit.SECONDS);
    
    // 此时执行截图，就能捕捉到任务运行中的画面
    mActivityTestRule.runOnUiThread(new Runnable() {
        @Override
        public void run() {
            mScreenshotWatcher.captureScreenshot("task_running_screenshot");
        }
    });
}

方案2：自定义IdlingResource，让Espresso不等待AsyncTask #

如果你需要在AsyncTask运行期间随时执行测试操作（而非特定阶段），可以实现自定义IdlingResource，覆盖Espresso默认的AsyncTask等待机制，让它允许在任务运行时执行操作。

步骤1：实现自定义IdlingResource #

public class AsyncTaskIdlingResource implements IdlingResource {
    private ResourceCallback mCallback;
    private final AtomicBoolean mIsIdle = new AtomicBoolean(true);

    public AsyncTaskIdlingResource() {
        // 后台线程监听AsyncTask的执行状态
        AsyncTask.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    // 反射获取AsyncTask的线程池
                    Field executorField = AsyncTask.class.getDeclaredField("sExecutor");
                    executorField.setAccessible(true);
                    Executor executor = (Executor) executorField.get(null);
                    
                    if (executor instanceof ThreadPoolExecutor) {
                        ThreadPoolExecutor threadPool = (ThreadPoolExecutor) executor;
                        while (true) {
                            boolean hasActiveTasks = threadPool.getActiveCount() > 0;
                            // 当任务状态变化时，通知Espresso
                            if (mIsIdle.get() != hasActiveTasks) {
                                mIsIdle.set(hasActiveTasks);
                                if (mCallback != null) {
                                    mCallback.onTransitionToIdle();
                                }
                            }
                            Thread.sleep(100);
                        }
                    }
                } catch (Exception e) {
                    throw new RuntimeException("Failed to track AsyncTask state", e);
                }
            }
        });
    }

    @Override
    public String getName() {
        return AsyncTaskIdlingResource.class.getSimpleName();
    }

    @Override
    public boolean isIdleNow() {
        // 返回true表示Espresso可以执行操作，即使有AsyncTask在运行
        return true;
    }

    @Override
    public void registerIdleTransitionCallback(ResourceCallback callback) {
        mCallback = callback;
    }
}

步骤2：在测试类中注册/注销IdlingResource #

@Rule
public ActivityTestRule<MainActivity> mActivityTestRule = new ActivityTestRule<>(MainActivity.class);

private AsyncTaskIdlingResource mAsyncTaskIdlingResource;

@Before
public void setUp() {
    // 注册自定义IdlingResource
    mAsyncTaskIdlingResource = new AsyncTaskIdlingResource();
    IdlingRegistry.getInstance().register(mAsyncTaskIdlingResource);
}

@After
public void tearDown() {
    // 测试结束后注销，避免影响其他测试
    IdlingRegistry.getInstance().unregister(mAsyncTaskIdlingResource);
}

@Test
public void captureAnyTimeDuringTask() {
    onView(withId(R.id.start_task_button)).perform(click());
    
    // 此时Espresso不会等待AsyncTask完成，可以直接执行截图
    mActivityTestRule.runOnUiThread(new Runnable() {
        @Override
        public void run() {
            mScreenshotWatcher.captureScreenshot("task_running_screenshot");
        }
    });
}

需要注意：这种方式会让Espresso不再自动等待AsyncTask完成，后续的测试操作需要自己处理同步逻辑，避免出现竞态条件。

内容的提问来源于stack exchange，提问作者Nicola Beghin