/** * Gets an Activity in the RESUMED stage. * <p> * This method should never be called from the Main thread. In certain situations there might * be more than one Activities in RESUMED stage, but only one is returned. * See {@link ActivityLifecycleMonitor}. */ public static Activity getCurrentActivity() throws IllegalStateException { // The array is just to wrap the Activity and be able to access it from the Runnable. final Activity[] resumedActivity = new Activity[1]; getInstrumentation().runOnMainSync(new Runnable() { public void run() { Collection resumedActivities = ActivityLifecycleMonitorRegistry.getInstance() .getActivitiesInStage(RESUMED); if (resumedActivities.iterator().hasNext()) { resumedActivity[0] = (Activity) resumedActivities.iterator().next(); } else { throw new IllegalStateException("No Activity in stage RESUMED"); } } }); return resumedActivity[0]; }
/** * Gets an Activity in the RESUMED stage. * <p> * This method should never be called from the Main thread. In certain situations there might * be more than one Activities in RESUMED stage, but only one is returned. * See {@link ActivityLifecycleMonitor}. */ public static Activity getCurrentActivity() throws IllegalStateException { // The array is just to wrap the Activity and be able to access it from the Runnable. final Activity[] resumedActivity = new Activity[1]; getInstrumentation().runOnMainSync(new Runnable() { public void run() { Collection resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(RESUMED); if(resumedActivities.iterator().hasNext()) { resumedActivity[0] = (Activity) resumedActivities.iterator().next(); } else { throw new IllegalStateException("No Activity in stage RESUMED"); } } }); return resumedActivity[0]; }
@NonNull public List<Activity> findAllInStage(final Stage activityStage) { final List<Activity> foundActivities = new ArrayList<>(); Runnable task = new Runnable() { @Override public void run() { foundActivities.addAll(ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(activityStage)); } }; if (Looper.myLooper() != Looper.getMainLooper()) { InstrumentationRegistry.getInstrumentation().runOnMainSync(task); } else { task.run(); } return foundActivities; }
@Override public void perform(UiController uiController, View view) { uiController.loopMainThreadUntilIdle(); final Activity activity = (Activity) view.getContext(); activity.setRequestedOrientation(orientation); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } Collection<Activity> resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); if (resumedActivities.isEmpty()) { throw new RuntimeException("Could not change orientation"); } }
@Test public void loader_manager_is_retained_across_config_changes() { final LoaderManager firstLoaderManager = activityRule.getActivity().fragment.loaderManager; final TestActivityWithFragment firstActivity = activityRule.getActivity(); i.runOnMainSync(new Runnable() { @Override public void run() { firstActivity.recreate(); } }); i.waitForIdleSync(); i.runOnMainSync(new Runnable() { @Override public void run() { TestActivityWithFragment secondActivity = (TestActivityWithFragment) ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED).iterator().next(); LoaderManager secondLoaderManager = secondActivity.fragment.loaderManager; assertNotSame(firstActivity.fragment, secondActivity.fragment); assertSame(firstLoaderManager, secondLoaderManager); } }); }
@Test public void loader_manager_is_retained_across_config_changes() { final LoaderManager firstLoaderManager = activityRule.getActivity().loaderManager; final Activity firstActivity = activityRule.getActivity(); i.runOnMainSync(new Runnable() { @Override public void run() { firstActivity.recreate(); } }); i.waitForIdleSync(); i.runOnMainSync(new Runnable() { @Override public void run() { TestActivity secondActivity = (TestActivity) ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED).iterator().next(); LoaderManager secondLoaderManager = secondActivity.loaderManager; assertNotSame(firstActivity, secondActivity); assertSame(firstLoaderManager, secondLoaderManager); } }); }
@Test public void loader_manager_is_retained_across_config_changes() { final LoaderManager firstLoaderManager = activityRule.getActivity().fragment.fragment.loaderManager; final TestActivityWithNestedFragment firstActivity = activityRule.getActivity(); i.runOnMainSync(new Runnable() { @Override public void run() { firstActivity.recreate(); } }); i.waitForIdleSync(); i.runOnMainSync(new Runnable() { @Override public void run() { TestActivityWithNestedFragment secondActivity = (TestActivityWithNestedFragment) ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED).iterator().next(); LoaderManager secondLoaderManager = secondActivity.fragment.fragment.loaderManager; assertNotSame(firstActivity.fragment.fragment, secondActivity.fragment.fragment); assertSame(firstLoaderManager, secondLoaderManager); } }); }
@Test public void loader_manager_is_retained_across_config_changes() { final LoaderManager firstLoaderManager = activityRule.getActivity().controller.loaderManager; final Activity firstActivity = activityRule.getActivity(); i.runOnMainSync(new Runnable() { @Override public void run() { firstActivity.recreate(); } }); i.waitForIdleSync(); i.runOnMainSync(new Runnable() { @Override public void run() { TestActivity secondActivity = (TestActivity) ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED).iterator().next(); LoaderManager secondLoaderManager = secondActivity.controller.loaderManager; assertNotSame(firstActivity, secondActivity); assertSame(firstLoaderManager, secondLoaderManager); } }); }
@SuppressWarnings("unchecked") @Override public Activity startActivitySync(@NonNull Intent intent) { ComponentName componentName = intent.getComponent(); Class<? extends Activity> cls; try { cls = (Class<? extends Activity>) Class.forName(componentName.getClassName()); } catch (ClassNotFoundException e) { throw new RuntimeException(e); } Activity activity = Robolectric.setupActivity(cls); ActivityLifecycleMonitorRegistry.registerInstance(activityLifecycleMonitor); activityLifecycleMonitor.signalLifecycleChange(Stage.CREATED, activity); activityLifecycleMonitor.signalLifecycleChange(Stage.STARTED, activity); activityLifecycleMonitor.signalLifecycleChange(Stage.RESUMED, activity); return activity; }
/** * Retrieves the on going activity * @return Activity - The current activity */ private static Activity getActivityInstance(){ getInstrumentation().runOnMainSync(new Runnable() { public void run() { Collection resumedActivities = ActivityLifecycleMonitorRegistry.getInstance() .getActivitiesInStage(Stage.RESUMED); if (resumedActivities.iterator().hasNext()) { mResumedActivity = (Activity) resumedActivities.iterator().next(); } if (resumedActivities.size() <= 0 ){ mResumedActivity = null; } } }); return mResumedActivity; }
/** * Gets an instance of the currently active (displayed) activity. * @param activityTestRule test rule * @param <T> activity class * @return activity instance */ public static <T extends Activity> T getCurrentActivity(@NonNull ActivityTestRule activityTestRule) { getInstrumentation().waitForIdleSync(); final Activity[] activity = new Activity[1]; try { activityTestRule.runOnUiThread(new Runnable() { @Override public void run() { java.util.Collection<Activity> activites = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); activity[0] = Iterables.getOnlyElement(activites); }}); } catch (Throwable throwable) { throwable.printStackTrace(); } //noinspection unchecked return (T) activity[0]; }
void takeScreenshot(final String path) { InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { @Override public void run() { Collection<Activity> resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); Iterator<Activity> iterator = resumedActivities.iterator(); if (iterator.hasNext()) { Activity activity = iterator.next(); try { takeScreenshot(activity, path); } catch (Exception e) { // ignore } } } }); }
@Override public void perform(UiController uiController, View view) { uiController.loopMainThreadUntilIdle(); final Activity activity = getActivity(view); activity.runOnUiThread(new Runnable() { @Override public void run() { activity.setRequestedOrientation(orientation); } }); Collection<Activity> resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); uiController.loopMainThreadUntilIdle(); SystemClock.sleep(512); if (resumedActivities.isEmpty()) { throw new RuntimeException("Could not change orientation"); } }
@Override public TestActivity getActivity() { Runnable runnable = new Runnable() { @Override public void run() { Collection<Activity> activities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); if (activities.isEmpty()) { mActivity = null; } else { mActivity = (TestActivity) activities.iterator().next(); } } }; if (Looper.myLooper() == Looper.getMainLooper()) { runnable.run(); } else { getInstrumentation().runOnMainSync(runnable); getInstrumentation().waitForIdleSync(); } return mActivity == null ? super.getActivity() : mActivity; }
public Activity getDisplayedActivityInstance() { final Activity[] currentActivity = new Activity[1]; getInstrumentation().runOnMainSync(new Runnable() { public void run() { Collection<Activity> resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(RESUMED); if (resumedActivities.iterator().hasNext()) { currentActivity[0] = resumedActivities.iterator().next(); } } }); return currentActivity[0]; }
private static Activity getActivityInstance() { final Activity[] currentActivity = {null}; getInstrumentation().runOnMainSync(new Runnable() { public void run() { Collection resumedActivities = ActivityLifecycleMonitorRegistry.getInstance() .getActivitiesInStage(RESUMED); if (resumedActivities.iterator().hasNext()) { currentActivity[0] = (Activity) resumedActivities.iterator().next(); } } }); return currentActivity[0]; }
private static Set<Activity> getActivitiesInStages(Stage... stages) { final Set<Activity> activities = Sets.newHashSet(); final ActivityLifecycleMonitor instance = ActivityLifecycleMonitorRegistry.getInstance(); for (Stage stage : stages) { final Collection<Activity> activitiesInStage = instance.getActivitiesInStage(stage); if (activitiesInStage != null) { activities.addAll(activitiesInStage); } } return activities; }
@Override public void perform(UiController uiController, View view) { uiController.loopMainThreadUntilIdle(); final Activity activity = (Activity) view.getContext(); activity.setRequestedOrientation(orientation); Collection<Activity> resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); if (resumedActivities.isEmpty()) { throw new RuntimeException("Could not change orientation"); } }
protected static Activity getActivityInstance(){ InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { public void run(){ Collection<Activity> resumedActivity = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); for(Activity act : resumedActivity){ // Log.i("Chimp-needs-to-know","Got activity : " + act.toString()); current = act; } } }); return current; }
public static Activity getCurrentActivity() { final Activity[] currentActivity = {null}; Collection resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(RESUMED); if (resumedActivities.iterator().hasNext()) { currentActivity[0] = (Activity) resumedActivities.iterator().next(); } return currentActivity[0]; }
@Then("^Toast with text \"([^\"]*)\" is displayed") public void toastIsDisplayed(String text) throws Exception { final Activity[] activity = new Activity[1]; InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { @Override public void run() { activity[0] = (Activity) ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED).toArray()[0]; } }); onView(withText(text)).inRoot(withDecorView(not(is(activity[0].getWindow().getDecorView())))).check(matches(isDisplayed())); }
protected Activity getActivityInstance() { final Activity[] currentActivity = {null}; getInstrumentation().runOnMainSync(new Runnable() { public void run() { Collection<Activity> resumedActivity = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); Iterator<Activity> it = resumedActivity.iterator(); currentActivity[0] = it.next(); } }); return currentActivity[0]; }
public static void makeAllProgressBarsIdleForAllResumedActivities(Instrumentation instrumentation) { instrumentation.runOnMainSync(new Runnable() { public void run() { Collection<Activity> resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(RESUMED); if (resumedActivities.isEmpty()) { throw new RuntimeException("Could not change orientation"); } for (Activity activity : resumedActivities) { makeAllProgressBarsIdle(activity.findViewById(android.R.id.content).getRootView()); } } }); }
private Activity getCurrentActivity() { final Activity[] currentActivity = new Activity[1]; getInstrumentation().runOnMainSync(new Runnable() { public void run() { Collection<Activity> resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(RESUMED); if (resumedActivities.iterator().hasNext()){ currentActivity[0] = resumedActivities.iterator().next(); } } }); return currentActivity[0]; }
public static Set<Activity> getActivitiesInStages(Stage... stages) { final Set<Activity> activities = Sets.newHashSet(); final ActivityLifecycleMonitor instance = ActivityLifecycleMonitorRegistry.getInstance(); for (Stage stage : stages) { final Collection<Activity> activitiesInStage = instance.getActivitiesInStage(stage); if (activitiesInStage != null) { activities.addAll(activitiesInStage); } } return activities; }
protected Activity getCurrentActivity() { InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() { public void run() { Collection<Activity> resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(RESUMED); if (resumedActivities.iterator().hasNext()) { mCurrentActivity = resumedActivities.iterator().next(); } } }); return mCurrentActivity; }
public Activity getActivityInstance() { final Activity[] currentActivity = new Activity[1]; getInstrumentation().runOnMainSync(() -> { Collection resumedActivities = ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); if (resumedActivities.iterator().hasNext()) { currentActivity[0] = (Activity) resumedActivities.iterator().next(); } }); return currentActivity[0]; }
public static Set<Activity> getActivitiesInStages(Stage... stages) { final Set<Activity> activities = Sets.newHashSet(); final ActivityLifecycleMonitor instance = ActivityLifecycleMonitorRegistry.getInstance(); for (Stage stage : stages) { activities.addAll(instance.getActivitiesInStage(stage)); } return activities; }
/** * Retrieves the on going activity * @return Activity - The current activity */ private static Activity getActivityInstance(){ getInstrumentation().runOnMainSync(new Runnable() { public void run() { Collection resumedActivities = ActivityLifecycleMonitorRegistry.getInstance() .getActivitiesInStage(Stage.RESUMED); if (resumedActivities.iterator().hasNext()) { mResumedActivity = (Activity) resumedActivities.iterator().next(); } } }); return mResumedActivity; }