Package org.robolectric.shadows

Class ShadowPausedLooper

java.lang.Object
org.robolectric.shadows.ShadowLooper
org.robolectric.shadows.ShadowPausedLooper
@Implements(value=android.os.Looper.class, isInAndroidSdk=false) public final class ShadowPausedLooper extends ShadowLooper
The shadow Looper for and @link LooperMode.Mode.INSTRUMENTATION_TEST.

This shadow differs from the legacy ShadowLegacyLooper in the following ways:\ - Has no connection to Scheduler. Its APIs are standalone - The main looper is always paused in PAUSED MODE but can be unpaused in INSTRUMENTATION_TEST mode. When a looper is paused, posted messages to it are not executed unless idle() is called. - Just like in real Android, each looper has its own thread, and posted tasks get executed in that thread. - - There is only a single SystemClock value that all loopers read from. Unlike legacy behavior where each Scheduler kept their own clock value.

This class should not be used directly; use ShadowLooper instead.

  • Constructor Details

    • ShadowPausedLooper

      public ShadowPausedLooper()

  • Method Details

    • __constructor__

      @Implementation protected void __constructor__(boolean quitAllowed)

    • getLoopers

      protected static Collection<Looper> getLoopers()

    • quitUnchecked

      public void quitUnchecked()
      Specified by:
      quitUnchecked in class ShadowLooper

    • hasQuit

      public boolean hasQuit()
      Specified by:
      hasQuit in class ShadowLooper

    • idle

      public void idle()
      Description copied from class: ShadowLooper
      Executes all posted tasks scheduled before or at the current time.
      Specified by:
      idle in class ShadowLooper

    • idleFor

      public void idleFor(long time, TimeUnit timeUnit)
      Description copied from class: ShadowLooper
      Advances the system clock by the given time, then executes all posted tasks scheduled before or at the given time.
      Specified by:
      idleFor in class ShadowLooper

    • isIdle

      public boolean isIdle()
      Description copied from class: ShadowLooper
      Returns true if there are no pending tasks scheduled to be executed before current time.
      Specified by:
      isIdle in class ShadowLooper

    • unPause

      public void unPause()
      Description copied from class: ShadowLooper
      Not supported for the main Looper in LooperMode.Mode.PAUSED.
      Specified by:
      unPause in class ShadowLooper

    • pause

      public void pause()
      Description copied from class: ShadowLooper
      Pause the looper.

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

      Specified by:
      pause in class ShadowLooper

    • isPaused

      public boolean isPaused()
      Specified by:
      isPaused in class ShadowLooper

    • setPaused

      public boolean setPaused(boolean shouldPause)
      Description copied from class: ShadowLooper
      Control the paused state of the Looper.

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

      Specified by:
      setPaused in class ShadowLooper

    • resetScheduler

      public void resetScheduler()
      Description copied from class: ShadowLooper
      Only supported for LooperMode.Mode.LEGACY.
      Specified by:
      resetScheduler in class ShadowLooper

    • reset

      public void reset()
      Description copied from class: ShadowLooper
      Causes all enqueued tasks to be discarded, and pause state to be reset
      Specified by:
      reset in class ShadowLooper

    • idleIfPaused

      public void idleIfPaused()
      Description copied from class: ShadowLooper
      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.

      Specified by:
      idleIfPaused in class ShadowLooper

    • idleConstantly

      public void idleConstantly(boolean shouldIdleConstantly)
      Specified by:
      idleConstantly in class ShadowLooper

    • runToEndOfTasks

      public void runToEndOfTasks()
      Description copied from class: ShadowLooper
      Causes all of the Runnables that have been scheduled to run while advancing the clock to the start time of the last scheduled Runnable.
      Specified by:
      runToEndOfTasks in class ShadowLooper

    • runToNextTask

      public void runToNextTask()
      Description copied from class: ShadowLooper
      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.
      Specified by:
      runToNextTask in class ShadowLooper

    • runOneTask

      public void runOneTask()
      Description copied from class: ShadowLooper
      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.
      Specified by:
      runOneTask in class ShadowLooper

    • post

      public boolean post(Runnable runnable, long delayMillis)
      Description copied from class: ShadowLooper
      Enqueue a task to be run later.
      Specified by:
      post in class ShadowLooper
      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:

    • postAtFrontOfQueue

      public boolean postAtFrontOfQueue(Runnable runnable)
      Description copied from class: ShadowLooper
      Enqueue a task to be run ahead of all other delayed tasks.
      Specified by:
      postAtFrontOfQueue in class ShadowLooper
      Parameters:
      runnable - the task to be run
      Returns:
      true if the runnable is enqueued
      See Also:

    • postSync

      public void postSync(Runnable runnable)
      Posts the runnable to the looper and idles until the runnable has been run. Generally clients should prefer to use Instrumentation.runOnMainSync(Runnable), which will reraise underlying runtime exceptions to the caller.

    • runPaused

      public void runPaused(Runnable runnable)
      Description copied from class: ShadowLooper
      Runs the current task with the looper paused.

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

      Specified by:
      runPaused in class ShadowLooper

    • poll

      public void poll(long timeout)
      Polls the message queue waiting until a message is posted to the head of the queue. This will suspend the thread until a new message becomes available. Returns immediately if the queue is not idle. There's no guarantee that the message queue will not still be idle when returning, but if the message queue becomes not idle it will return immediately.

      This method is only applicable for the main looper's queue when called on the main thread, as the main looper in Robolectric is processed manually (it doesn't loop)--looper threads are using the native polling of their loopers. Throws an exception if called for another looper's queue. Non-main thread loopers should use unPause().

      This should be used with care, it can be used to suspend the main (i.e. test) thread while worker threads perform some work, and then resumed by posting to the main looper. Used in a loop to wait on some condition it can process messages on the main looper, simulating the behavior of the real looper, for example: 

      
 while (!condition) {
   shadowMainLooper.poll(timeout);
   shadowMainLooper.idle();
 }

      Beware though that a message must be posted to the main thread after the condition is satisfied, or the condition satisfied while idling the main thread, otherwise the main thread will continue to be suspended until the timeout.

      Parameters:
      timeout - Timeout in milliseconds, the maximum time to wait before returning, or 0 to wait indefinitely,

    • getNextScheduledTaskTime

      public Duration getNextScheduledTaskTime()
      Specified by:
      getNextScheduledTaskTime in class ShadowLooper
      Returns:
      the scheduled time of the next posted task; Duration.ZERO if there is no currently scheduled task.

    • getLastScheduledTaskTime

      public Duration getLastScheduledTaskTime()
      Specified by:
      getLastScheduledTaskTime in class ShadowLooper
      Returns:
      the scheduled time of the last posted task; Duration.ZERO 0 if there is no currently scheduled task.

    • resetLoopers

      @Resetter public static void resetLoopers()

    • prepareMainLooper

      @Implementation protected static void prepareMainLooper()

    • quit

      @Implementation protected void quit()

    • quitSafely

      @Implementation(minSdk=18) protected void quitSafely()

    • getScheduler

      public Scheduler getScheduler()
      Description copied from class: ShadowLooper
      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.

      Specified by:
      getScheduler in class ShadowLooper
      Returns:
      the Scheduler that is being used to manage the enqueued tasks.

    • setIgnoreUncaughtExceptions

      @Deprecated public static void setIgnoreUncaughtExceptions(boolean shouldIgnore)
      Deprecated.
      this method only exists to accommodate legacy tests with preexisting issues. Silently discarding exceptions is not recommended, and can lead to deadlocks.
      By default Robolectric will put Loopers that throw uncaught exceptions in their loop method into an error state, where any future posting to the looper's queue will throw an error.

      This API allows you to disable this behavior. Note this is a permanent setting - it is not reset between tests.

    • loop

      @Implementation protected static void loop()
      Shadow loop to handle uncaught exceptions. Without this logic an uncaught exception on a looper thread will cause idle() to deadlock.