ShadowLooper

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

```
@Implements(value=android.os.Looper.class)
public class ShadowLooper
extends java.lang.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 android.os.Looper`	`getLooperForThread(java.lang.Thread thread)`
`protected static android.os.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, java.util.concurrent.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, java.util.concurrent.TimeUnit unit)`
`static void`	`idleMainLooperConstantly(boolean shouldIdleConstantly)`
`boolean`	`isPaused()`
`protected static void`	`loop()`
`protected static android.os.Looper`	`myLooper()`
`void`	`pause()`
`static void`	`pauseLooper(android.os.Looper looper)`
`static void`	`pauseMainLooper()`
`boolean`	`post(java.lang.Runnable runnable, long delayMillis)` Deprecated. Use a `Handler` instance to post to a looper.
`boolean`	`postAtFrontOfQueue(java.lang.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(java.lang.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(android.os.Looper looper)`
`static void`	`unPauseMainLooper()`

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 android.os.Looper getMainLooper()
```
  - myLooper
```
@Implementation
protected static android.os.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 android.os.Looper getLooperForThread(java.lang.Thread thread)
```
  - pauseLooper
```
public static void pauseLooper(android.os.Looper looper)
```
  - unPauseLooper
```
public static void unPauseLooper(android.os.Looper looper)
```
  - pauseMainLooper
```
public static void pauseMainLooper()
```
  - unPauseMainLooper
```
public static void unPauseMainLooper()
```
  - 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,
                                  java.util.concurrent.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,
                 java.util.concurrent.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(java.lang.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(java.lang.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(java.lang.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