How to use

Instrumentation$ActivityMonitor

in

android.app

/**
 * Waits for an activity to be started if one is not provided
 * by the constructor.
 */
private final void waitForActivityIfNotAvailable(){
  if(activityStack.isEmpty() || activityStack.peek().get() == null){
    if (activityMonitor != null) {
      Activity activity = activityMonitor.getLastActivity();
      while (activity == null){
        sleeper.sleepMini();
        activity = activityMonitor.getLastActivity();
      }
      addActivityToStack(activity);
    }
    else if(config.trackActivities){
      sleeper.sleepMini();
      setupActivityMonitor();
      waitForActivityIfNotAvailable();
    }
  }
}

@Before
public void initActivity() {
  instrumentation = InstrumentationRegistry.getInstrumentation();
  Instrumentation.ActivityMonitor monitor = new Instrumentation.ActivityMonitor(TestActivity.class.getName(), null, false);
  instrumentation.addMonitor(monitor);
  Intent intent = new Intent(instrumentation.getTargetContext(), TestActivity.class);
  intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  instrumentation.startActivitySync(intent);
  activity = instrumentation.waitForMonitor(monitor);
  assertNotNull(activity);
}

public InstrumentationActivityMonitorAssert hasHits(int hits) {
 isNotNull();
 int actualHits = actual.getHits();
 assertThat(actualHits) //
   .overridingErrorMessage("Expected hits <%s> but was <%s>.", hits, actualHits) //
   .isEqualTo(hits);
 return this;
}

if (activityMonitor.getLastActivity() != null)
  activity = activityMonitor.getLastActivity();

/**
 * Waits for the given {@link Activity}.
 *
 * @param activityClass the class of the {@code Activity} to wait for
 * @param timeout the amount of time in milliseconds to wait
 * @return {@code true} if {@code Activity} appears before the timeout and {@code false} if it does not
 *
 */
public boolean waitForActivity(Class<? extends Activity> activityClass, int timeout){
  if(isActivityMatching(activityClass, activityUtils.getCurrentActivity(false, false))){
    return true;
  }
  
  boolean foundActivity = false;
  ActivityMonitor activityMonitor = getActivityMonitor();
  long currentTime = SystemClock.uptimeMillis();
  final long endTime = currentTime + timeout;
  while(currentTime < endTime){
    Activity currentActivity = activityMonitor.waitForActivityWithTimeout(endTime - currentTime);
    
    if(currentActivity != null && currentActivity.getClass().equals(activityClass)) {
      foundActivity = true;
      break;
    }        
    currentTime = SystemClock.uptimeMillis();
  }
  removeMonitor(activityMonitor);
  return foundActivity;
}

@Test
 @UiThreadTest
 public void testLoginSuccess() {
   Instrumentation.ActivityMonitor monitor = InstrumentationRegistry.getInstrumentation().addMonitor(EventsListActivity.class.getName(), null, true);
   onView(withId(R.id.btnLogInW)).perform(click());
   onView(withId(R.id.email)).perform(typeText("good.email@example.com"));
   onView(withId(R.id.passL)).perform(typeText("strong.password"));
   onView(withId(R.id.btnLogInL)).perform(click());
   User user = new User();
   user.first_name = "Fake name";
   user.last_name = "Fake name";
   user.id = 1;
   user.email = "fake.email@gmail.com";
   final AuthResponse authResponse = new AuthResponse();
   authResponse.api_key = "fake_api_key";
   authResponse.status = "ok";
   authResponse.user = user;
   Mockito.verify(api).login(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), argumentCaptor.capture());
   InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
     @Override public void run() {
       argumentCaptor.getValue().success(authResponse, null);
     }
   });
   assertThat(1, equalTo(monitor.getHits()));
   InstrumentationRegistry.getInstrumentation().removeMonitor(monitor);
 }

/**
 * Waits for the given {@link Activity}.
 *
 * @param name the name of the {@code Activity} to wait for e.g. {@code "MyActivity"}
 * @param timeout the amount of time in milliseconds to wait
 * @return {@code true} if {@code Activity} appears before the timeout and {@code false} if it does not
 *
 */
public boolean waitForActivity(String name, int timeout){
  if(isActivityMatching(activityUtils.getCurrentActivity(false, false), name)){
    return true;
  }
  
  boolean foundActivity = false;
  ActivityMonitor activityMonitor = getActivityMonitor();
  long currentTime = SystemClock.uptimeMillis();
  final long endTime = currentTime + timeout;
  while(currentTime < endTime){
    Activity currentActivity = activityMonitor.waitForActivityWithTimeout(endTime - currentTime);
    
    if(isActivityMatching(currentActivity, name)){
      foundActivity = true;
      break;
    }    
    currentTime = SystemClock.uptimeMillis();
  }
  removeMonitor(activityMonitor);
  return foundActivity;
}

/**
 * Waits for an activity to be started if one is not provided
 * by the constructor.
 */
private final void waitForActivityIfNotAvailable(){
  if(activityStack.isEmpty() || activityStack.peek().get() == null){
    if (activityMonitor != null) {
      Activity activity = activityMonitor.getLastActivity();
      while (activity == null){
        sleeper.sleepMini();
        activity = activityMonitor.getLastActivity();
      }
      addActivityToStack(activity);
    }
    else if(config.trackActivities){
      sleeper.sleepMini();
      setupActivityMonitor();
      waitForActivityIfNotAvailable();
    }
  }
}

 public void testKillCreateLifeCycle() throws Throwable {
  Instrumentation.ActivityMonitor mainActivityMonitor = new Instrumentation.ActivityMonitor(MainActivity.class.getName(), null, false);
  getInstrumentation().addMonitor(mainActivityMonitor);

  final Activity activity = getActivity();
  mainActivityMonitor.waitForActivityWithTimeout(5000);

  navigateToFragment(activity);

  runTestOnUiThread(new Runnable() {
    @Override
    public void run() {
      activity.recreate();
    }
  });
  getInstrumentation().waitForIdleSync();

  Activity newActivity = mainActivityMonitor.getLastActivity();
  assertFragmentIsVisible((FragmentActivity) newActivity, getExpectedFragment());
}

 private Instrumentation.ActivityMonitor mBrowserActivityMonitor;

protected void setUp() throws Exception {
  super.setUp();

  mBrowserActivityMonitor = new Instrumentation.ActivityMonitor(Browser.class.getName(), null, false);
  getInstrumentation().addMonitor(mBrowserActivityMonitor);
  //...
}


public void testOpen()
{
  //...

  Activity activity = mBrowserActivityMonitor.waitForActivityWithTimeout(5 * 1000);
  assertNotNull("Activity was not started", activity);

  //...

}

Instrumentation.ActivityMonitor monitor = getInstrumentation()
   .addMonitor(Instrumentation.ActivityMonitor.class.getName(),
   null, false);
 // Wait for activity to fix inject error; Increase or decrease as needed
 monitor.waitForActivityWithTimeout(2000);
 // Should no longer fail
 TouchUtils.clickView(this, someView);

public void testButton() {
  Instrumentation.ActivityMonitor activityMonitor = getInstrumentation()
     .addMonitor(TargetActivity.class.getName(), null, false);
 //button.performClick(); // Dont use this method
 TouchUtils.clickView(this, button);
 TargetActivity targetActivity = (TargetActivity) activityMonitor.waitForActivity(); // By using ActivityMonitor
 // TargetActivity targetActivity = (TargetActivity) activityMonitor.waitForActivityWithTimeout(5);// It also works
 // TargetActivity targetActivity = (TargetActivity) getInstrumentation().waitForMonitor(activityMonitor); // By using Instrumentation
 // TargetActivity targetActivity = (TargetActivity) getInstrumentation().waitForMonitorWithTimeout(activityMonitor, 5); // It also works
 assertNotNull("Target Activity is not launched", targetActivity);
}

  @Override
  public void startsWithIntentAction(String intentAction) {
    ActivityMonitor monitor = instrumentation.addMonitor(intentAction, null, false);

    performPendingAction();

    assertTrue(instrumentation.checkMonitorHit(monitor, 1));

    Activity lastActivity = monitor.getLastActivity();
    getStoryTestCase().setCurrentActivity(lastActivity);

  }
}

@Override
public void starts(Class<? extends Activity> activityClass) {
  ActivityMonitor monitor = instrumentation.addMonitor(activityClass.getCanonicalName(),
      null, false);
  performPendingAction();
  assertTrue(instrumentation.checkMonitorHit(monitor, 1));
  Activity lastActivity = monitor.getLastActivity();
  getStoryTestCase().setCurrentActivity(lastActivity);
}

@SuppressWarnings("unchecked")
public static <T extends Activity> T monitorActivity(@NonNull Class<T> activityClass, int timeOut, @NonNull Runnable runnable) {
  Instrumentation.ActivityMonitor monitor = new Instrumentation.ActivityMonitor(activityClass.getCanonicalName(), null, false);
  try {
    InstrumentationRegistry.getInstrumentation().addMonitor(monitor);
    runnable.run();
    return (T) monitor.waitForActivityWithTimeout(timeOut);
  } finally {
    InstrumentationRegistry.getInstrumentation().removeMonitor(monitor);
  }
}

 public InstrumentationActivityMonitorAssert hasLastActivity(Activity activity) {
  isNotNull();
  Activity actualActivity = actual.getLastActivity();
  assertThat(actualActivity) //
    .overridingErrorMessage("Expected last activity <%s> but was <%s>.", activity,
      actualActivity) //
    .isSameAs(activity);
  return this;
 }
}

void monitorActivities() {
  if(activityMonitor != null){
    Activity activity = activityMonitor.waitForActivityWithTimeout(2000L);
    if(activity != null){
      if (activitiesStoredInActivityStack.remove(activity.toString())){
        removeActivityFromStack(activity);
      }
      if(!activity.isFinishing()){
        addActivityToStack(activity);
      }
    }
  }
}

public InstrumentationActivityMonitorAssert hasHits(int hits) {
 isNotNull();
 int actualHits = actual.getHits();
 assertThat(actualHits) //
   .overridingErrorMessage("Expected hits <%s> but was <%s>.", hits, actualHits) //
   .isEqualTo(hits);
 return this;
}

/**
 * Waits for the given {@link Activity}.
 *
 * @param activityClass the class of the {@code Activity} to wait for
 * @param timeout the amount of time in milliseconds to wait
 * @return {@code true} if {@code Activity} appears before the timeout and {@code false} if it does not
 *
 */
public boolean waitForActivity(Class<? extends Activity> activityClass, int timeout){
  if(isActivityMatching(activityClass, activityUtils.getCurrentActivity(false, false))){
    return true;
  }
  
  boolean foundActivity = false;
  ActivityMonitor activityMonitor = getActivityMonitor();
  long currentTime = SystemClock.uptimeMillis();
  final long endTime = currentTime + timeout;
  while(currentTime < endTime){
    Activity currentActivity = activityMonitor.waitForActivityWithTimeout(endTime - currentTime);
    
    if(currentActivity != null && currentActivity.getClass().equals(activityClass)) {
      foundActivity = true;
      break;
    }        
    currentTime = SystemClock.uptimeMillis();
  }
  removeMonitor(activityMonitor);
  return foundActivity;
}

/**
 * Waits for the given {@link Activity}.
 *
 * @param name the name of the {@code Activity} to wait for e.g. {@code "MyActivity"}
 * @param timeout the amount of time in milliseconds to wait
 * @return {@code true} if {@code Activity} appears before the timeout and {@code false} if it does not
 *
 */
public boolean waitForActivity(String name, int timeout){
  if(isActivityMatching(activityUtils.getCurrentActivity(false, false), name)){
    return true;
  }
  
  boolean foundActivity = false;
  ActivityMonitor activityMonitor = getActivityMonitor();
  long currentTime = SystemClock.uptimeMillis();
  final long endTime = currentTime + timeout;
  while(currentTime < endTime){
    Activity currentActivity = activityMonitor.waitForActivityWithTimeout(endTime - currentTime);
    
    if(isActivityMatching(currentActivity, name)){
      foundActivity = true;
      break;
    }    
    currentTime = SystemClock.uptimeMillis();
  }
  removeMonitor(activityMonitor);
  return foundActivity;
}