Package org.robolectric.shadows

Class ShadowPausedLooper

  • @Implements(value=android.os.Looper.class,
            isInAndroidSdk=false)
public final class ShadowPausedLooper
extends ShadowLooper
    The shadow Looper for LooperMode.Mode.PAUSED.

    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. Posted messages 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 Detail

      • ShadowPausedLooper

        public ShadowPausedLooper()

    • Method Detail

      • __constructor__

        @Implementation
protected void __constructor__​(boolean quitAllowed)

      • 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

      • 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

      • 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:
        Handler.postDelayed(Runnable,long)

      • 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()

      • 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.