Handler createAsync(looper: Looper)

Create a new Handler whose posted messages and runnables are not subject to synchronization barriers such as display vsync.

Messages sent to an async handler are guaranteed to be ordered with respect to one another, but not necessarily with respect to messages from other Handlers.

Handler createAsync(looper: Looper, callback: Handler.Callback)

Create a new Handler whose posted messages and runnables are not subject to synchronization barriers such as display vsync.

Messages sent to an async handler are guaranteed to be ordered with respect to one another, but not necessarily with respect to messages from other Handlers.

Unit dispatchMessage(msg: Message)

Handle system messages here.

Unit dump(pw: Printer, prefix: String) Looper getLooper() String getMessageName(message: Message)

Returns a string representing the name of the specified message. The default implementation will either return the class name of the message callback if any, or the hexadecimal representation of the message "what" field.

Unit handleMessage(msg: Message)

Subclasses must implement this to receive messages.

Boolean hasCallbacks(r: Runnable)

Check if there are any pending posts of messages with callback r in the message queue.

This operation is worst case O(n) in the number of messages in the queue, and should be avoided. Instead consider another mechanism outside of the queue to track if messages were enqueued and dispatched. For instance, maintain a counter, incrementing it when enqueuing a message and decrementing it when handling a message.

Boolean hasMessages(what: Int)

Check if there are any pending posts of messages with code 'what' in the message queue.

This operation is worst case O(n) in the number of messages in the queue, and should be avoided. Instead consider another mechanism outside of the queue to track if messages were enqueued and dispatched. For instance, maintain a counter, incrementing it when enqueuing a message and decrementing it when handling a message.

Boolean hasMessages(what: Int, object: Any?)

Check if there are any pending posts of messages with code 'what' and whose obj is 'object' in the message queue.

This operation is worst case O(n) in the number of messages in the queue, and should be avoided. Instead consider another mechanism outside of the queue to track if messages were enqueued and dispatched. For instance, maintain a counter, incrementing it when enqueuing a message and decrementing it when handling a message.

Message obtainMessage()

Returns a new Message from the global message pool. More efficient than creating and allocating new instances. The retrieved message has its handler set to this instance (Message.target == this). If you don't want that facility, just call Message.obtain() instead.

Message obtainMessage(what: Int)

Same as obtainMessage(), except that it also sets the what member of the returned Message.

Message obtainMessage(what: Int, arg1: Int, arg2: Int)

Same as obtainMessage(), except that it also sets the what, arg1 and arg2 members of the returned Message.

Message obtainMessage(what: Int, arg1: Int, arg2: Int, obj: Any?)

Same as obtainMessage(), except that it also sets the what, obj, arg1,and arg2 values on the returned Message.

Message obtainMessage(what: Int, obj: Any?)

Same as obtainMessage(), except that it also sets the what and obj members of the returned Message.

Boolean post(r: Runnable)

Causes the Runnable r to be added to the message queue. The runnable will be run on the thread to which this handler is attached.

Boolean postAtFrontOfQueue(r: Runnable)

Posts a message to an object that implements Runnable. Causes the Runnable r to executed on the next iteration through the message queue. The runnable will be run on the thread to which this handler is attached. This method is only for use in very special circumstances -- it can easily starve the message queue, cause ordering problems, or have other unexpected side-effects.

Boolean postAtTime(r: Runnable, token: Any?, uptimeMillis: Long)

Causes the Runnable r to be added to the message queue, to be run at a specific time given by uptimeMillis. The time-base is android.os.SystemClock#uptimeMillis. Time spent in deep sleep will add an additional delay to execution. The runnable will be run on the thread to which this handler is attached.

Boolean postAtTime(r: Runnable, uptimeMillis: Long)

Causes the Runnable r to be added to the message queue, to be run at a specific time given by uptimeMillis. The time-base is android.os.SystemClock#uptimeMillis. Time spent in deep sleep will add an additional delay to execution. The runnable will be run on the thread to which this handler is attached.

Boolean postDelayed(r: Runnable, token: Any?, delayMillis: Long)

Causes the Runnable r to be added to the message queue, to be run after the specified amount of time elapses. The runnable will be run on the thread to which this handler is attached. The time-base is android.os.SystemClock#uptimeMillis. Time spent in deep sleep will add an additional delay to execution.

Boolean postDelayed(r: Runnable, delayMillis: Long)

Causes the Runnable r to be added to the message queue, to be run after the specified amount of time elapses. The runnable will be run on the thread to which this handler is attached. The time-base is android.os.SystemClock#uptimeMillis. Time spent in deep sleep will add an additional delay to execution.

Unit removeCallbacks(r: Runnable)

Remove any pending posts of Runnable r that are in the message queue.

This operation is worst case O(n) in the number of messages in the queue, and should be avoided. Instead consider another mechanism outside of the queue to cancel a pending operation. For instance, maintain a flag to indicate whether the operation should be performed differently or not at all once it is dispatched.

Unit removeCallbacks(r: Runnable, token: Any?)

Remove any pending posts of Runnable r with Object token that are in the message queue. If token is null, all callbacks will be removed.

This operation is worst case O(n) in the number of messages in the queue, and should be avoided. Instead consider another mechanism outside of the queue to cancel a pending operation. For instance, maintain a flag to indicate whether the operation should be performed differently or not at all once it is dispatched.

Unit removeCallbacksAndMessages(token: Any?)

Remove any pending posts of callbacks and sent messages whose obj is token. If token is null, all callbacks and messages will be removed.

Unit removeMessages(what: Int)

Remove any pending posts of messages with code 'what' that are in the message queue. Note that `Message#what` is 0 unless otherwise set. When calling `postMessage(Runnable)` or `postAtTime(Runnable, long)`, the `Runnable` is internally wrapped with a `Message` whose `what` is 0. Calling `removeMessages(0)` will remove all messages without a `what`, including posted `Runnable`s.

This operation is worst case O(n) in the number of messages in the queue, and should be avoided. Instead consider another mechanism outside of the queue to cancel a pending operation. For instance, maintain a flag to indicate whether the operation should be performed differently or not at all once it is dispatched.

Unit removeMessages(what: Int, object: Any?)

Remove any pending posts of messages with code 'what' and whose obj is 'object' that are in the message queue. If object is null, all messages will be removed.

This operation is worst case O(n) in the number of messages in the queue, and should be avoided. Instead consider another mechanism outside of the queue to cancel a pending operation. For instance, maintain a flag to indicate whether the operation should be performed differently or not at all once it is dispatched.

Boolean sendEmptyMessage(what: Int)

Sends a Message containing only the what value.

Boolean sendEmptyMessageAtTime(what: Int, uptimeMillis: Long)

Sends a Message containing only the what value, to be delivered at a specific time.

Boolean sendEmptyMessageDelayed(what: Int, delayMillis: Long)

Sends a Message containing only the what value, to be delivered after the specified amount of time elapses.

Boolean sendMessage(msg: Message)

Pushes a message onto the end of the message queue after all pending messages before the current time. It will be received in handleMessage, in the thread attached to this handler.

Boolean sendMessageAtFrontOfQueue(msg: Message)

Enqueue a message at the front of the message queue, to be processed on the next iteration of the message loop. You will receive it in handleMessage, in the thread attached to this handler. This method is only for use in very special circumstances -- it can easily starve the message queue, cause ordering problems, or have other unexpected side-effects.

Boolean sendMessageAtTime(msg: Message, uptimeMillis: Long)

Enqueue a message into the message queue after all pending messages before the absolute time (in milliseconds) uptimeMillis. The time-base is android.os.SystemClock#uptimeMillis. Time spent in deep sleep will add an additional delay to execution. You will receive it in handleMessage, in the thread attached to this handler.

Boolean sendMessageDelayed(msg: Message, delayMillis: Long)

Enqueue a message into the message queue after all pending messages before (current time + delayMillis). You will receive it in handleMessage, in the thread attached to this handler.

String toString()

Returns a string representation of the object.