ShadowLooper

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

```
@Implements(value=android.os.Looper.class)
public class ShadowLooper
extends Object
```
Robolectric enqueues posted Runnables to be run (on this thread) later. Runnables that are scheduled to run immediately can be triggered by calling idle().

See Also:

ShadowMessageQueue

Constructor Summary

Constructors
Constructor and Description

ShadowLooper()

Constructors
Constructor and Description
`ShadowLooper()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`__constructor__(boolean quitAllowed)`
`static Looper`	`getLooperForThread(Thread thread)`
`protected static Looper`	`getMainLooper()`
`Scheduler`	`getScheduler()` Returns the `Scheduler` that is being used to manage the enqueued tasks.
`static ShadowLooper`	`getShadowMainLooper()` Deprecated. Use `shadowOf(Looper.getMainLooper())` instead.
`boolean`	`hasQuit()`
`void`	`idle()` Causes `Runnable`s that have been scheduled to run immediately to actually run.
`void`	`idle(long intervalMillis)` Deprecated. Use `idle(long, TimeUnit)`.
`void`	`idle(long amount, TimeUnit unit)` Causes `Runnable`s that have been scheduled to run within the next specified amount of time to run while advancing the scheduler’s clock.
`void`	`idleConstantly(boolean shouldIdleConstantly)`
`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)`
`boolean`	`isPaused()`
`protected static void`	`loop()`
`protected static Looper`	`myLooper()`
`void`	`pause()`
`static void`	`pauseLooper(Looper looper)` Pauses execution of tasks posted to the ShadowLooper.
`static void`	`pauseMainLooper()` Puts the main ShadowLooper in an “paused” state.
`boolean`	`post(Runnable runnable, long delayMillis)` Deprecated. Use a `Handler` instance to post to a looper.
`boolean`	`postAtFrontOfQueue(Runnable runnable)` Deprecated. Use a `Handler` instance to post to a looper.
`protected void`	`quit()`
`protected void`	`quitSafely()`
`void`	`quitUnchecked()`
`void`	`reset()` Causes all enqueued tasks to be discarded, and pause state to be reset
`void`	`resetScheduler()`
`static void`	`resetThreadLoopers()`
`static void`	`runMainLooperOneTask()`
`static void`	`runMainLooperToNextTask()`
`void`	`runOneTask()` Causes only one of the next `Runnable`s that have been scheduled to run while advancing the scheduler’s clock to its start time.
`void`	`runPaused(Runnable r)`
`void`	`runToEndOfTasks()` Causes all of the `Runnable`s that have been scheduled to run while advancing the scheduler’s clock to the start time of the last scheduled `Runnable`.
`void`	`runToNextTask()` Causes the next `Runnable`(s) that have been scheduled to run while advancing the scheduler’s 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.
`boolean`	`setPaused(boolean shouldPause)`
`void`	`unPause()`
`static void`	`unPauseLooper(Looper looper)` Puts the shadow looper in an “unpaused” state (this is the default state).
`static void`	`unPauseMainLooper()` Puts the main ShadowLooper 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
  - resetThreadLoopers
```
@Resetter
public static void resetThreadLoopers()
```
  - __constructor__
```
@Implementation
protected void __constructor__(boolean quitAllowed)
```
  - getMainLooper
```
@Implementation
protected static Looper getMainLooper()
```
  - myLooper
```
@Implementation
protected static Looper myLooper()
```
  - loop
```
@Implementation
protected static void loop()
```
  - quit
```
@Implementation
protected void quit()
```
  - quitSafely
```
@Implementation(minSdk=18)
protected void quitSafely()
```
  - quitUnchecked
```
public void quitUnchecked()
```
  - hasQuit
```
public boolean hasQuit()
```
  - getShadowMainLooper
```
@Deprecated
public static ShadowLooper getShadowMainLooper()
```
    Deprecated. Use shadowOf(Looper.getMainLooper()) instead.
  - getLooperForThread
```
public static Looper getLooperForThread(Thread thread)
```
  - pauseLooper
```
public static void pauseLooper(Looper looper)
```
    Pauses execution of tasks posted to the ShadowLooper. 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 ShadowLooper in an “paused” state.
    
    See Also:
    
    pauseLooper(android.os.Looper)
  - unPauseMainLooper
```
public static void unPauseMainLooper()
```
    Puts the main ShadowLooper 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()
  - idle
```
public void idle()
```
    Causes Runnables that have been scheduled to run immediately to actually run. Does not advance the scheduler’s clock;
  - 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
```
public void idle(long amount,
                 TimeUnit unit)
```
    Causes Runnables that have been scheduled to run within the next specified amount of time to run while advancing the scheduler’s clock.
  - idleConstantly
```
public void idleConstantly(boolean shouldIdleConstantly)
```
  - runToEndOfTasks
```
public void runToEndOfTasks()
```
    Causes all of the Runnables that have been scheduled to run while advancing the scheduler’s clock to the start time of the last scheduled Runnable.
  - runToNextTask
```
public void runToNextTask()
```
    Causes the next Runnable(s) that have been scheduled to run while advancing the scheduler’s 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 void runOneTask()
```
    Causes only one of the next Runnables that have been scheduled to run while advancing the scheduler’s clock to its start time. Only one Runnable will run even if more than one has ben scheduled to run at the same time.
  - post
```
@Deprecated
public 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 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 void pause()
```
  - unPause
```
public void unPause()
```
  - isPaused
```
public boolean isPaused()
```
  - setPaused
```
public boolean setPaused(boolean shouldPause)
```
  - resetScheduler
```
public void resetScheduler()
```
  - reset
```
public void reset()
```
    Causes all enqueued tasks to be discarded, and pause state to be reset
  - getScheduler
```
public Scheduler getScheduler()
```
    Returns the Scheduler that is being used to manage the enqueued tasks. This scheduler is managed by the Looper’s associated queue.
    
    Returns:
    
    the Scheduler that is being used to manage the enqueued tasks.
  - runPaused
```
public void runPaused(Runnable r)
```

Class ShadowLooper

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ShadowLooper

Method Detail

resetThreadLoopers

__constructor__

getMainLooper

myLooper

loop

quit

quitSafely

quitUnchecked

hasQuit

getShadowMainLooper

getLooperForThread

pauseLooper

unPauseLooper

pauseMainLooper

unPauseMainLooper

idleMainLooper

idleMainLooper

idleMainLooper

idleMainLooperConstantly

runMainLooperOneTask

runMainLooperToNextTask

runUiThreadTasks

runUiThreadTasksIncludingDelayedTasks

idle

idle

idle

idleConstantly

runToEndOfTasks

runToNextTask

runOneTask

post

postAtFrontOfQueue

pause

unPause

isPaused

setPaused

resetScheduler

reset

getScheduler

runPaused

constructor