Package org.robolectric.shadows

Class ShadowLooper

    • Constructor Detail

      • ShadowLooper

        public ShadowLooper()

    • Method Detail

      • assertLooperMode

        public static void assertLooperMode​(LooperMode.Mode expectedMode)

      • getShadowMainLooper

        @Deprecated
public static ShadowLooper getShadowMainLooper()
        Deprecated.
        Use shadowOf({@link Looper#getMainLooper()}) instead.

      • shadowMainLooper

        public static ShadowLooper shadowMainLooper()

      • getLooperForThread

        public static Looper getLooperForThread​(Thread thread)

      • getAllLoopers

        public static Collection<Looper> getAllLoopers()
        Return all created loopers.

      • resetThreadLoopers

        public static void resetThreadLoopers()
        Should not be called directly - Robolectric internal use only.

      • clearLooperMode

        @Resetter
public static void clearLooperMode()

      • pauseLooper

        public static void pauseLooper​(Looper looper)
        Pauses execution of tasks posted to the ShadowLegacyLooper. This means that during tests, tasks sent to the looper will not execute immediately, but will be queued in a way that is similar to how a real looper works. These queued tasks must be executed explicitly by calling #runToEndOftasks or a similar method, otherwise they will not run at all before your test ends.
        Parameters:
        looper - the looper to pause

      • unPauseLooper

        public static void unPauseLooper​(Looper looper)
        Puts the shadow looper in an "unpaused" state (this is the default state). This means that during tests, tasks sent to the looper will execute inline, immediately, on the calling (main) thread instead of being queued, in a way similar to how Guava's "DirectExecutorService" works. This is likely not to be what you want: it will cause code to be potentially executed in a different order than how it would execute on the device, and if you are using certain Android APIs (such as view animations) that are non-reentrant, they may not work at all or do unpredictable things. For more information, see this discussion.
        Parameters:
        looper - the looper to pause

      • pauseMainLooper

        public static void pauseMainLooper()
        Puts the main ShadowLegacyLooper in an "paused" state.
        See Also:
        pauseLooper(android.os.Looper)

      • unPauseMainLooper

        public static void unPauseMainLooper()
        Puts the main ShadowLegacyLooper in an "unpaused" state.
        See Also:
        unPauseLooper(android.os.Looper)

      • idleMainLooper

        public static void idleMainLooper()

      • idleMainLooper

        @InlineMe(replacement="ShadowLooper.idleMainLooper(interval, MILLISECONDS)",
          imports="org.robolectric.shadows.ShadowLooper",
          staticImports="java.util.concurrent.TimeUnit.MILLISECONDS")
@Deprecated
public static void idleMainLooper​(long interval)
        Deprecated.
        Use idleMainLooper(long, TimeUnit).

      • idleMainLooper

        public static void idleMainLooper​(long amount,
                                  TimeUnit unit)

      • idleMainLooperConstantly

        public static void idleMainLooperConstantly​(boolean shouldIdleConstantly)

      • runMainLooperOneTask

        public static void runMainLooperOneTask()

      • runMainLooperToNextTask

        public static void runMainLooperToNextTask()

      • runUiThreadTasksIncludingDelayedTasks

        public static void runUiThreadTasksIncludingDelayedTasks()
        Runs all runnable tasks (pending and future) that have been queued on the UI thread. Such tasks may be queued by e.g. Activity.runOnUiThread(Runnable) or AsyncTask.onPostExecute(Object).

        **Note:** calling this method does not pause or un-pause the scheduler, however the clock is advanced as future tasks are run.

        See Also:
        runUiThreadTasks()

      • quitUnchecked

        public abstract void quitUnchecked()

      • hasQuit

        public abstract boolean hasQuit()

      • idle

        public abstract void idle()
        Executes all posted tasks scheduled before or at the current time.

      • idleFor

        public abstract void idleFor​(long time,
                             TimeUnit timeUnit)
        Advances the system clock by the given time, then executes all posted tasks scheduled before or at the given time.

      • isIdle

        public abstract boolean isIdle()
        Returns true if there are no pending tasks scheduled to be executed before current time.

      • unPause

        public abstract void unPause()
        Not supported for the main Looper in LooperMode.Mode.PAUSED.

      • isPaused

        public abstract boolean isPaused()

      • setPaused

        public abstract boolean setPaused​(boolean shouldPause)
        Control the paused state of the Looper.

        Not supported for the main Looper in LooperMode.Mode.PAUSED.

      • resetScheduler

        public abstract void resetScheduler()
        Only supported for LooperMode.Mode.LEGACY.

      • reset

        public abstract void reset()
        Causes all enqueued tasks to be discarded, and pause state to be reset

      • getScheduler

        public abstract Scheduler getScheduler()
        Returns the Scheduler that is being used to manage the enqueued tasks. This scheduler is managed by the Looper's associated queue.

        Only supported for LooperMode.Mode.LEGACY.

        Returns:
        the Scheduler that is being used to manage the enqueued tasks.

      • runPaused

        public abstract void runPaused​(Runnable run)
        Runs the current task with the looper paused.

        When LooperMode is PAUSED, this will execute all pending tasks scheduled before the current time.

      • idleIfPaused

        public abstract void idleIfPaused()
        Helper method to selectively call idle() only if LooperMode is PAUSED.

        Intended for backwards compatibility, to avoid changing behavior for tests still using LEGACY LooperMode.

      • idle

        @Deprecated
@InlineMe(replacement="this.idleFor(Duration.ofMillis(intervalMillis))",
          imports="java.time.Duration")
public final void idle​(long intervalMillis)
        Deprecated.
        Use idleFor(Duration).
        Causes Runnables that have been scheduled to run within the next intervalMillis milliseconds to run while advancing the scheduler's clock.

      • idle

        @Deprecated
@InlineMe(replacement="this.idleFor(amount, unit)")
public final void idle​(long amount,
                       TimeUnit unit)
        Deprecated.
        use idleFor(long, TimeUnit)
        Causes Runnables that have been scheduled to run within the next specified amount of time to run while advancing the clock.

      • idleConstantly

        public abstract void idleConstantly​(boolean shouldIdleConstantly)

      • runToEndOfTasks

        public abstract void runToEndOfTasks()
        Causes all of the Runnables that have been scheduled to run while advancing the clock to the start time of the last scheduled Runnable.

      • runToNextTask

        public abstract void runToNextTask()
        Causes the next Runnable(s) that have been scheduled to run while advancing the clock to its start time. If more than one Runnable is scheduled to run at this time then they will all be run.

      • runOneTask

        public abstract void runOneTask()
        Causes only one of the next Runnables that have been scheduled to run while advancing the clock to its start time. Only one Runnable will run even if more than one has been scheduled to run at the same time.

      • post

        @Deprecated
public abstract boolean post​(Runnable runnable,
                             long delayMillis)
        Deprecated.
        Use a Handler instance to post to a looper.
        Enqueue a task to be run later.
        Parameters:
        runnable - the task to be run
        delayMillis - how many milliseconds into the (virtual) future to run it
        Returns:
        true if the runnable is enqueued
        See Also:
        Handler.postDelayed(Runnable,long)

      • postAtFrontOfQueue

        @Deprecated
public abstract boolean postAtFrontOfQueue​(Runnable runnable)
        Deprecated.
        Use a Handler instance to post to a looper.
        Enqueue a task to be run ahead of all other delayed tasks.
        Parameters:
        runnable - the task to be run
        Returns:
        true if the runnable is enqueued
        See Also:
        Handler.postAtFrontOfQueue(Runnable)

      • pause

        public abstract void pause()
        Pause the looper.

        Has no practical effect for realistic looper, since it is always paused.

      • getNextScheduledTaskTime

        public abstract Duration getNextScheduledTaskTime()
        Returns:
        the scheduled time of the next posted task; Duration.ZERO if there is no currently scheduled task.

      • getLastScheduledTaskTime

        public abstract Duration getLastScheduledTaskTime()
        Returns:
        the scheduled time of the last posted task; Duration.ZERO 0 if there is no currently scheduled task.