androidx.test.runner.lifecycle.Stage Java Examples

@Override
public Collection<Activity> getActivitiesInStage(Stage stage) {
  checkMainThread();
  checkNotNull(stage);

  List<Activity> activities = new ArrayList<Activity>();
  Iterator<ActivityStatus> statusIterator = activityStatuses.iterator();
  while (statusIterator.hasNext()) {
    ActivityStatus status = statusIterator.next();
    Activity statusActivity = status.activityRef.get();
    if (null == statusActivity) {
      statusIterator.remove();
    } else if (stage == status.lifecycleStage) {
      activities.add(statusActivity);
    }
  }

  return activities;
}
 

@Suppress
@UiThreadTest
public void testOnStartStopCalled() {
  startActivity(new Intent(), null, null);

  // if we dont pair start/stop together the test runner will block until a timeout
  // occurs waiting for the activity to stop.
  getInstrumentation().callActivityOnStart(spiedActivity);
  assertThat(spiedActivity, isIn(monitor.getActivitiesInStage(Stage.STARTED)));
  assertThat(monitor.getLifecycleStageOf(spiedActivity), is(Stage.STARTED));

  getInstrumentation().callActivityOnStop(spiedActivity);
  assertThat(spiedActivity, isIn(monitor.getActivitiesInStage(Stage.STOPPED)));
  assertThat(monitor.getLifecycleStageOf(spiedActivity), is(Stage.STOPPED));

  InOrder order = inOrder(spiedActivity, callback);
  order.verify(spiedActivity).onStart();
  order.verify(callback).onActivityLifecycleChanged(spiedActivity, Stage.STARTED);
  order.verify(spiedActivity).onStop();
  order.verify(callback).onActivityLifecycleChanged(spiedActivity, Stage.STOPPED);
}
 

@Override
public void run() {
  List<Activity> activities = new ArrayList<>();

  for (Stage s : EnumSet.range(Stage.CREATED, Stage.STOPPED)) {
    activities.addAll(lifecycleMonitor.getActivitiesInStage(s));
  }

  if (activities.size() > 0) {
    Log.i(TAG, "Activities that are still in CREATED to STOPPED: " + activities.size());
  }

  for (Activity activity : activities) {
    if (!activity.isFinishing()) {
      try {
        Log.i(TAG, "Finishing activity: " + activity);
        activity.finish();
      } catch (RuntimeException e) {
        Log.e(TAG, "Failed to finish activity.", e);
      }
    }
  }
}
 

@Test
public void testAddRemoveListener() {
  ActivityLifecycleCallback callback = mock(ActivityLifecycleCallback.class);

  // multiple adds should only register once.
  monitor.addLifecycleCallback(callback);
  monitor.addLifecycleCallback(callback);
  monitor.addLifecycleCallback(callback);

  monitor.signalLifecycleChange(Stage.CREATED, activity);
  monitor.signalLifecycleChange(Stage.STARTED, activity);

  // multiple removes should no-op.
  monitor.removeLifecycleCallback(callback);
  monitor.removeLifecycleCallback(callback);

  monitor.signalLifecycleChange(Stage.DESTROYED, activity);

  verify(callback).onActivityLifecycleChanged(activity, Stage.CREATED);
  verify(callback).onActivityLifecycleChanged(activity, Stage.STARTED);
  verify(callback, never()).onActivityLifecycleChanged(activity, Stage.DESTROYED);
}
 

@Override
public Stage getLifecycleStageOf(Activity activity) {
  checkMainThread();
  checkNotNull(activity);
  Iterator<ActivityStatus> statusIterator = activityStatuses.iterator();
  while (statusIterator.hasNext()) {
    ActivityStatus status = statusIterator.next();
    Activity statusActivity = status.activityRef.get();
    if (null == statusActivity) {
      statusIterator.remove();
    } else if (activity == statusActivity) {
      return status.lifecycleStage;
    }
  }
  throw new IllegalArgumentException("Unknown activity: " + activity);
}
 

private static List<IBinder> getResumedActivityTokens() {
  ActivityLifecycleMonitor activityLifecycleMonitor =
      ActivityLifecycleMonitorRegistry.getInstance();
  Collection<Activity> resumedActivities =
      activityLifecycleMonitor.getActivitiesInStage(Stage.RESUMED);
  if (resumedActivities.isEmpty()) {
    Log.w(
        TAG,
        "suppressed: NoActivityResumedException(\"At least one activity should"
            + " be in RESUMED stage.\"");
  }
  List<IBinder> tokens = Lists.newArrayList();
  for (Activity activity : resumedActivities) {
    tokens.add(activity.getWindow().getDecorView().getApplicationWindowToken());
  }
  return tokens;
}
 

@Test
public void recreateActivityShouldWork() throws Exception {
  activityScenarioRule.getScenario().recreate();
  activityScenarioRule
      .getScenario()
      .onActivity(
          activity -> {
            assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.RESUMED);
            assertThat(activity.getNumberOfRecreations()).isEqualTo(1);
            assertThat(activity.getIntent())
                .extras()
                .string("MyIntentParameterKey")
                .isEqualTo("MyIntentParameterValue");
          });
}
 

@Override
public void onActivityLifecycleChanged(Activity activity, Stage stage) {
  if (activityClass.isInstance(activity)) {
    if (Stage.RESUMED == stage) {
      ActivityTestRule.this.activity = makeWeakReference(activityClass.cast(activity));
    } else if (Stage.PAUSED == stage) {
      // If there is an activity result we save it
      if (activity.isFinishing() && activityResult != null) {
        setActivityResultForActivity(activityClass.cast(activity));
      }
    }
  }
}
 

@Test
public void recreateActivityShouldWork() throws Exception {
  activityScenarioRule.getScenario().recreate();
  activityScenarioRule
      .getScenario()
      .onActivity(
          activity -> {
            assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.RESUMED);
            assertThat(activity.getNumberOfRecreations()).isEqualTo(1);
          });
}
 

@Override
public void callActivityOnStop(Activity activity) {
  try {
    super.callActivityOnStop(activity);
    lifecycleMonitor.signalLifecycleChange(Stage.STOPPED, activity);
  } finally {
    startedActivityCounter.decrementAndGet();
  }
}
 

@Test
public void activityShouldBeResumedAutomatically() throws Exception {
  activityScenarioRule
      .getScenario()
      .onActivity(
          activity -> {
            assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.RESUMED);
            assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
          });
}
 

@Test
public void activityShouldBeResumedAutomatically() throws Exception {
  activityScenarioRule
      .getScenario()
      .onActivity(
          activity -> {
            assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.RESUMED);
            assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
            assertThat(activity.getIntent())
                .extras()
                .string("MyIntentParameterKey")
                .isEqualTo("MyIntentParameterValue");
          });
}
 

private static Activity getRootActivity(UiController uiController) {
  Collection<Activity> resumedActivities =
      ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED);
  if (resumedActivities.isEmpty()) {
    uiController.loopMainThreadUntilIdle();
    resumedActivities =
        ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED);
  }
  checkState(
      resumedActivities.size() == 1,
      "More than one activity is in RESUMED stage."
          + " There may have been an error during the activity creation/startup process,"
          + " please check your logs.");
  return getOnlyElement(resumedActivities);
}
 

@Test
public void recreateResumedActivity() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.recreate();
    assertThat(scenario.getState()).isEqualTo(State.RESUMED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.RESUMED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(1);
        });
  }
}
 

@Test
public void recreateStartedActivity() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.STARTED);
    scenario.recreate();
    assertThat(scenario.getState()).isEqualTo(State.STARTED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.PAUSED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(1);
        });
  }
}
 

@Test
public void recreateCreatedActivity() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.CREATED);
    scenario.recreate();
    assertThat(scenario.getState()).isEqualTo(State.CREATED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.STOPPED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(1);
        });
  }
}
 

/** Returns the list of all non-destroyed activities. */
private List<Activity> getAllActiveActivities() {
  List<Activity> activities = Lists.newArrayList();
  for (Stage s : EnumSet.range(Stage.PRE_ON_CREATE, Stage.RESTARTED)) {
    activities.addAll(activityLifecycleMonitor.getActivitiesInStage(s));
  }
  return activities;
}
 

@Override
public void callActivityOnStart(Activity activity) {
  startedActivityCounter.incrementAndGet();
  try {
    super.callActivityOnStart(activity);
    lifecycleMonitor.signalLifecycleChange(Stage.STARTED, activity);
  } catch (RuntimeException re) {
    startedActivityCounter.decrementAndGet();
    throw re;
  }
}
 

@UiThreadTest
public void testOnDestroyCalled() {
  startActivity(new Intent(), null, null);
  getInstrumentation().callActivityOnDestroy(spiedActivity);

  assertThat(spiedActivity, isIn(monitor.getActivitiesInStage(Stage.DESTROYED)));
  assertThat(monitor.getLifecycleStageOf(spiedActivity), is(Stage.DESTROYED));
  InOrder order = inOrder(spiedActivity, callback);
  order.verify(spiedActivity).onDestroy();
  order.verify(callback).onActivityLifecycleChanged(spiedActivity, Stage.DESTROYED);
}
 

@Test
public void fromStartedToResumed() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.STARTED);
    scenario.moveToState(State.RESUMED);
    assertThat(scenario.getState()).isEqualTo(State.RESUMED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.RESUMED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}
 

@Test
public void fromStartedToStarted() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.STARTED);
    scenario.moveToState(State.STARTED);
    assertThat(scenario.getState()).isEqualTo(State.STARTED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.PAUSED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}
 

@Test
public void fromStartedToCreated() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.STARTED);
    scenario.moveToState(State.CREATED);
    assertThat(scenario.getState()).isEqualTo(State.CREATED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.STOPPED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}
 

@Test
public void fromCreatedToResumed() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.CREATED);
    scenario.moveToState(State.RESUMED);
    assertThat(scenario.getState()).isEqualTo(State.RESUMED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.RESUMED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}
 

@Test
public void fromCreatedToStarted() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.CREATED);
    scenario.moveToState(State.STARTED);
    assertThat(scenario.getState()).isEqualTo(State.STARTED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.PAUSED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}
 

@Test
public void fromCreatedToCreated() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.CREATED);
    scenario.moveToState(State.CREATED);
    assertThat(scenario.getState()).isEqualTo(State.CREATED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.STOPPED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}
 

@Test
public void fromResumedToResumed() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.RESUMED);
    assertThat(scenario.getState()).isEqualTo(State.RESUMED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.RESUMED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}
 

@Test
public void fromResumedToStarted() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.STARTED);
    assertThat(scenario.getState()).isEqualTo(State.STARTED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.PAUSED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}
 

@Test
public void fromResumedToCreated() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    scenario.moveToState(State.CREATED);
    assertThat(scenario.getState()).isEqualTo(State.CREATED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.STOPPED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}
 

private static void checkActivityStageIsIn(Activity activity, Set<Stage> expected) {
  getInstrumentation()
      .runOnMainSync(
          () -> {
            Stage stage =
                ActivityLifecycleMonitorRegistry.getInstance().getLifecycleStageOf(activity);
            checkState(
                expected.contains(stage),
                "Activity's stage must be %s but was %s",
                expected,
                stage);
          });
}
 

@Test
public void launchedActivityShouldBeResumed() throws Exception {
  try (ActivityScenario<RecreationRecordingActivity> scenario =
      ActivityScenario.launch(RecreationRecordingActivity.class)) {
    assertThat(scenario.getState()).isEqualTo(State.RESUMED);
    scenario.onActivity(
        activity -> {
          assertThat(lastLifeCycleTransition(activity)).isEqualTo(Stage.RESUMED);
          assertThat(activity.getNumberOfRecreations()).isEqualTo(0);
        });
  }
}