ShadowLooper (shadows-core 3.1-rc1 API)

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

```
@Implements(value=android.os.Looper.class)
public class ShadowLooper
extends Object
```
Shadow for Looper that 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
`void`	`__constructor__(boolean quitAllowed)`
`static android.os.Looper`	`getLooperForThread(Thread thread)`
`static android.os.Looper`	`getMainLooper()`
`org.robolectric.util.Scheduler`	`getScheduler()` Returns the `Scheduler` that is being used to manage the enqueued tasks.
`static ShadowLooper`	`getShadowMainLooper()`
`boolean`	`hasQuit()`
`void`	`idle()` Causes `Runnable`s that have been scheduled to run immediately to actually run.
`void`	`idle(long intervalMillis)` Causes `Runnable`s that have been scheduled to run within the next `intervalMillis` milliseconds to run while advancing the scheduler's clock.
`void`	`idleConstantly(boolean shouldIdleConstantly)`
`static void`	`idleMainLooper()`
`static void`	`idleMainLooper(long interval)`
`static void`	`idleMainLooperConstantly(boolean shouldIdleConstantly)`
`boolean`	`isPaused()`
`static void`	`loop()`
`static android.os.Looper`	`myLooper()`
`void`	`pause()`
`static void`	`pauseLooper(android.os.Looper looper)`
`static void`	`pauseMainLooper()`
`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.
`int`	`postSyncBarrier()`
`void`	`quit()`
`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(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
public void __constructor__(boolean quitAllowed)
```
  - getMainLooper
```
@Implementation
public static android.os.Looper getMainLooper()
```
  - myLooper
```
@Implementation
public static android.os.Looper myLooper()
```
  - loop
```
@Implementation
public static void loop()
```
  - quit
```
@Implementation
public void quit()
```
  - quitUnchecked
```
public void quitUnchecked()
```
  - postSyncBarrier
```
@HiddenApi
 @Implementation
public int postSyncBarrier()
```
  - hasQuit
```
public boolean hasQuit()
```
  - getShadowMainLooper
```
public static ShadowLooper getShadowMainLooper()
```
  - getLooperForThread
```
public static android.os.Looper getLooperForThread(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
```
public static void idleMainLooper(long interval)
```
  - 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
```
public void idle(long intervalMillis)
```
    Causes Runnables that have been scheduled to run within the next intervalMillis milliseconds to run while advancing the scheduler's clock.
    
    Parameters:
    
    intervalMillis - milliseconds to advance
  - 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 org.robolectric.util.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

quitUnchecked

postSyncBarrier

hasQuit

getShadowMainLooper

getLooperForThread

pauseLooper

unPauseLooper

pauseMainLooper

unPauseMainLooper

idleMainLooper

idleMainLooper

idleMainLooperConstantly

runMainLooperOneTask

runMainLooperToNextTask

runUiThreadTasks

runUiThreadTasksIncludingDelayedTasks

idle

idle

idleConstantly

runToEndOfTasks

runToNextTask

runOneTask

post

postAtFrontOfQueue

pause

unPause

isPaused

setPaused

resetScheduler

reset

getScheduler

runPaused

constructor