ShadowLooper

java.lang.Object
- org.robolectric.shadows.ShadowLooper

Direct Known Subclasses:

ShadowLegacyLooper, ShadowPausedLooper
```
@Implements(value=android.os.Looper.class,
            shadowPicker=ShadowLooper.Picker.class)
public abstract class ShadowLooper
extends Object
```
The base shadow API class for controlling Loopers.

It will delegate calls to the appropriate shadow based on the current LooperMode.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ShadowLooper.Picker

Nested Classes
Modifier and Type	Class and Description
`static class`	`ShadowLooper.Picker`

Constructor Summary

Constructors
Constructor and Description

ShadowLooper()

Constructors
Constructor and Description
`ShadowLooper()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static void`	`assertLooperMode(LooperMode.Mode expectedMode)`
`abstract Duration`	`getLastScheduledTaskTime()`
`static Looper`	`getLooperForThread(Thread thread)`
`abstract Duration`	`getNextScheduledTaskTime()`
`abstract Scheduler`	`getScheduler()` Returns the `Scheduler` that is being used to manage the enqueued tasks.
`static ShadowLooper`	`getShadowMainLooper()` Deprecated. Use `shadowOf(Looper.getMainLooper())` instead.
`abstract boolean`	`hasQuit()`
`abstract void`	`idle()` Executes all posted tasks scheduled before or at the current time.
`void`	`idle(long intervalMillis)` Deprecated. Use `idle(long, TimeUnit)`.
`void`	`idle(long amount, TimeUnit unit)` Deprecated. use `idleFor(amount, unit)`
`abstract void`	`idleConstantly(boolean shouldIdleConstantly)`
`void`	`idleFor(Duration duration)` A variant of `idleFor(long, TimeUnit)` that accepts a Duration.
`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.
`abstract void`	`idleIfPaused()` Helper method to selectively call idle() only if LooperMode is PAUSED.
`static void`	`idleMainLooper()`
`static void`	`idleMainLooper(long interval)` Deprecated. Use `idleMainLooper(long, TimeUnit)`.
`static void`	`idleMainLooper(long amount, TimeUnit unit)`
`static void`	`idleMainLooperConstantly(boolean shouldIdleConstantly)`
`abstract boolean`	`isIdle()` Returns true if the looper has any pending tasks scheduled to be executed before current time.
`abstract boolean`	`isPaused()`
`static LooperMode.Mode`	`looperMode()` Return the current `LooperMode`.
`abstract void`	`pause()` Pause the looper.
`static void`	`pauseLooper(Looper looper)` Pauses execution of tasks posted to the ShadowLegacyLooper.
`static void`	`pauseMainLooper()` Puts the main ShadowLegacyLooper in an “paused” state.
`abstract boolean`	`post(Runnable runnable, long delayMillis)` Deprecated. Use a `Handler` instance to post to a looper.
`abstract boolean`	`postAtFrontOfQueue(Runnable runnable)` Deprecated. Use a `Handler` instance to post to a looper.
`abstract void`	`quitUnchecked()`
`abstract void`	`reset()` Causes all enqueued tasks to be discarded, and pause state to be reset
`abstract void`	`resetScheduler()` Only supported for `LooperMode.Mode.PAUSED`.
`static void`	`resetThreadLoopers()` Should not be called directly - Robolectric internal use only.
`static void`	`runMainLooperOneTask()`
`static void`	`runMainLooperToNextTask()`
`abstract void`	`runOneTask()` Causes only one of the next `Runnable`s that have been scheduled to run while advancing the clock to its start time.
`abstract void`	`runPaused(Runnable run)` Runs the current task with the looper paused.
`abstract void`	`runToEndOfTasks()` Causes all of the `Runnable`s that have been scheduled to run while advancing the clock to the start time of the last scheduled `Runnable`.
`abstract void`	`runToNextTask()` Causes the next `Runnable`(s) that have been scheduled to run while advancing the clock to its start time.
`static void`	`runUiThreadTasks()` Runs any immediately runnable tasks previously queued on the UI thread, e.g.
`static void`	`runUiThreadTasksIncludingDelayedTasks()` Runs all runnable tasks (pending and future) that have been queued on the UI thread.
`abstract boolean`	`setPaused(boolean shouldPause)` Control the paused state of the Looper.
`static ShadowLooper`	`shadowMainLooper()`
`abstract void`	`unPause()` Not supported for the main Looper in `LooperMode.Mode.PAUSED`.
`static void`	`unPauseLooper(Looper looper)` Puts the shadow looper in an “unpaused” state (this is the default state).
`static void`	`unPauseMainLooper()` Puts the main ShadowLegacyLooper in an “unpaused” state.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ShadowLooper
```
public ShadowLooper()
```
- Method Detail
  - assertLooperMode
```
public static void assertLooperMode(LooperMode.Mode expectedMode)
```
  - getShadowMainLooper
```
@Deprecated
public static ShadowLooper getShadowMainLooper()
```
    Deprecated. Use shadowOf(Looper.getMainLooper()) instead.
  - shadowMainLooper
```
public static ShadowLooper shadowMainLooper()
```
  - getLooperForThread
```
public static Looper getLooperForThread(Thread thread)
```
  - resetThreadLoopers
```
public static void resetThreadLoopers()
```
    Should not be called directly - Robolectric internal use only.
  - looperMode
```
public static LooperMode.Mode looperMode()
```
    Return the current LooperMode.
  - 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
```
@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()
```
  - runUiThreadTasks
```
public static void runUiThreadTasks()
```
    Runs any immediately runnable tasks previously queued on the UI thread, e.g. by Activity.runOnUiThread(Runnable) or AsyncTask.onPostExecute(Object).
    
    Note: calling this method does not pause or un-pause the scheduler.
    
    See Also:
    
    runUiThreadTasksIncludingDelayedTasks()
  - 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.
  - idleFor
```
public void idleFor(Duration duration)
```
    A variant of idleFor(long, TimeUnit) that accepts a Duration.
  - isIdle
```
public abstract boolean isIdle()
```
    Returns true if the looper has any 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.PAUSED.
  - 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.PAUSED.
    
    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
public void idle(long intervalMillis)
```
    Deprecated. Use idle(long, TimeUnit).
    
    Causes Runnables that have been scheduled to run within the next intervalMillis milliseconds to run while advancing the scheduler’s clock.
  - idle
```
@Deprecated
public void idle(long amount,
                 TimeUnit unit)
```
    Deprecated. use idleFor(amount, unit)
    
    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.

Class ShadowLooper

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ShadowLooper

Method Detail

assertLooperMode

getShadowMainLooper

shadowMainLooper

getLooperForThread

resetThreadLoopers

looperMode

pauseLooper

unPauseLooper

pauseMainLooper

unPauseMainLooper

idleMainLooper

idleMainLooper

idleMainLooper

idleMainLooperConstantly

runMainLooperOneTask

runMainLooperToNextTask

runUiThreadTasks

runUiThreadTasksIncludingDelayedTasks

quitUnchecked

hasQuit

idle

idleFor

idleFor

isIdle

unPause

isPaused

setPaused

resetScheduler

reset

getScheduler

runPaused

idleIfPaused

idle

idle

idleConstantly

runToEndOfTasks

runToNextTask

runOneTask

post

postAtFrontOfQueue

pause

getNextScheduledTaskTime

getLastScheduledTaskTime