IndirectPointerInjectionScope

fun advanceEventTime(durationMillis: Long = eventPeriodMillis): Unit

Adds the given durationMillis to the current event time, delaying the next event by that time.

fun cancel(delayMillis: Long = eventPeriodMillis): Unit

Sends a cancel event delayMillis after the last sent event to cancel the current gesture. The cancel event contains the current position of all active pointers.

fun currentPosition(pointerId: Int = 0): Offset?

Returns the current position of the given pointerId. The default pointerId is 0. The position is returned in the coordinate system of the device sending the input (see inputDeviceSize). It is NOT related to the screen location.

open fun down(position: Offset): Unit

Sends a down event for the default pointer at position on the indirect pointer input device sending the input. The position is NOT in the node's local coordinate system (see inputDeviceSize).

If no pointers are down yet, this will start a new Indirect pointer input gesture. If a gesture is already in progress, this event is sent at the same timestamp as the last event. If the given pointer is already down, @throws IllegalArgumentException.

fun down(pointerId: Int, position: Offset): Unit

Sends a down event for the pointer with the given pointerId at position on the external indirect pointer input device. The position is NOT in the node's local coordinate system (see inputDeviceSize).

If no pointers are down yet, this will start a new Indirect pointer input gesture. If a gesture is already in progress (that is, there are other pointer ids that are down), this event is sent at the same timestamp as the last event. You cannot call down with a pointer id that is already down.

fun move(delayMillis: Long = eventPeriodMillis): Unit

Sends a move event delayMillis after the last sent event without updating any of the pointer positions. This can be useful when batching movement of multiple pointers together, which can be done with updatePointerTo and updatePointerBy.

open fun moveBy(delta: Offset, delayMillis: Long = eventPeriodMillis): Unit

Sends a move event delayMillis after the last sent event on nodes in the focus path, with the position of the default pointer moved by the given delta. The default pointer has pointerId = 0.

If the pointer is not yet down, @throws IllegalArgumentException.

open fun moveBy(pointerId: Int, delta: Offset, delayMillis: Long = eventPeriodMillis): Unit

Sends a move event delayMillis after the last sent event on nodes in the focus path, with the position of the pointer with the given pointerId moved by the given delta.

If the pointer is not yet down, @throws IllegalArgumentException.

open fun moveTo(position: Offset, delayMillis: Long = eventPeriodMillis): Unit

Sends a move event delayMillis after the last sent event on nodes in the focus path, with the position of the default pointer updated to position. The position is NOT in the node's local coordinate system (see inputDeviceSize).

If the default pointer is not yet down, @throws IllegalArgumentException.

open fun moveTo(
    pointerId: Int,
    position: Offset,
    delayMillis: Long = eventPeriodMillis
): Unit

Sends a move event delayMillis after the last sent event on nodes in the focus path, with the position of the pointer with the given pointerId updated to position. The position is NOT in the node's local coordinate system (see inputDeviceSize).

If the pointer is not yet down, @throws IllegalArgumentException.

open fun moveWithHistory(
    relativeHistoricalTimes: List<Long>,
    historicalCoordinates: List<Offset>,
    delayMillis: Long = eventPeriodMillis
): Unit

Sends a move event delayMillis after the last sent event without updating any of the pointer positions, while adding the historicalCoordinates at the relativeHistoricalTimes to the move event. This corresponds to the scenario where the external device generates Indirect pointer input events quicker than can be dispatched and batches them together.

This overload is a convenience method for the common case where the gesture only has one pointer.

fun moveWithHistoryMultiPointer(
    relativeHistoricalTimes: List<Long>,
    historicalCoordinates: List<List<Offset>>,
    delayMillis: Long = eventPeriodMillis
): Unit

Sends a move event delayMillis after the last sent event without updating any of the pointer positions, while adding the historicalCoordinates at the relativeHistoricalTimes to the move event. This corresponds to the scenario where an external touchpad generates Indirect pointer input events quicker than can be dispatched and batches them together.

fun up(pointerId: Int = 0): Unit

Sends an up event for the pointer with the given pointerId, or the default pointer if pointerId is omitted, on nodes in the focus path.

open fun updatePointerBy(pointerId: Int, delta: Offset): Unit

Updates the position of the pointer with the given pointerId by the given delta, but does not send a move event. The move event can be sent with move.

If the pointer is not yet down, @throws IllegalArgumentException.

open fun updatePointerTo(position: Offset): Unit

Updates the position of the default pointer (pointerId = 0) to the given position within the indirect pointer input device's bounds, but does not send a move event. The move event can be sent with move. The position is NOT in the node's local coordinate system (see inputDeviceSize).

If the pointer is not yet down, @throws IllegalArgumentException.

fun updatePointerTo(pointerId: Int, position: Offset): Unit

Updates the position of the pointer with the given pointerId to the given position within the indirect pointer input device's bounds, but does not send a move event. The move event can be sent with move. The position is NOT in the node's local coordinate system (see inputDeviceSize).

If the pointer is not yet down, @throws IllegalArgumentException.

open val eventPeriodMillis: Long

The default time between two successive events.

val indirectPointerEventPrimaryDirectionalMotionAxis: IndirectPointerEventPrimaryDirectionalMotionAxis

The primary axis for motion from an IndirectPointerEvent. Indirect input devices (such as touchpads) that do not move a cursor on screen may define a primary axis for motion (such as scrolling). This facilitates the translation of a 2D input gesture into a 1D scroll on the screen. For example, an input device might be wide horizontally but narrow vertically. In such a case, it would designate X as its primary axis of motion. This means horizontal scrolling on the input device would cause a horizontal list to scroll horizontally, and a vertical list to scroll vertically - even though the direction of motion on the input device is horizontal in both cases.

val inputDeviceSize: IntSize

The dimensions of the external indirect pointer input device that provide the boundaries for indirect input. If you go outside these dimensions, the tests will throw an exception. Note: This is not related to the screen coordinates.

val viewConfiguration: ViewConfiguration

The ViewConfiguration in use by the SemanticsNode from the SemanticsNodeInteraction on which the input injection method is called.

fun IndirectPointerInjectionScope.click(position: Offset = inputDeviceCenter): Unit

Performs a click gesture (aka a tap) on nodes in the focus path.

The click is done at the given position within the indirect pointer input device's bounds, or the inputDeviceCenter if the position is omitted. The position is NOT in the node's local coordinate system (see IndirectPointerInjectionScope.inputDeviceSize).

fun IndirectPointerInjectionScope.doubleClick(
    position: Offset = inputDeviceCenter,
    delayMillis: Long = viewConfiguration.defaultDoubleTapDelayMillis
): Unit

Performs a double click gesture (aka a double tap) on nodes in the focus path.

The double click is done at the given position within the indirect pointer input device's bounds or inputDeviceCenter if the position is omitted. By default, the delayMillis between the first and the second click is halfway in between the minimum and maximum required delay for a double click. The position is NOT in the node's local coordinate system (see IndirectPointerInjectionScope.inputDeviceSize).

fun IndirectPointerInjectionScope.longClick(
    position: Offset = inputDeviceCenter,
    durationMillis: Long = viewConfiguration.longPressTimeoutMillis + 100
): Unit

Performs a long click gesture (aka a long press) on nodes in the focus path.

The long click is done at the given position within the indirect pointer input device's bounds, or inputDeviceCenter if the position is omitted. By default, the durationMillis of the press is 100ms longer than the minimum required duration for a long press. The position is NOT in the node's local coordinate system (see IndirectPointerInjectionScope.inputDeviceSize).

fun IndirectPointerInjectionScope.multiTouchSwipe(
    curves: List<(timeMillis: Long) -> Offset>,
    durationMillis: Long = 200,
    keyTimes: List<Long> = emptyList()
): Unit

Performs a multitouch swipe gesture on nodes in the focus path.

Each pointer follows curves from 0 till durationMillis. Sampling of an event is forced at all times defined in keyTimes. The time between events is kept as close to eventPeriodMillis as possible, given the constraints.

The coordinates are NOT in the node's local coordinate system (see IndirectPointerInjectionScope.inputDeviceSize) and is usually used for focused movement (that is, a focused node would move to the next/previous focusable node in the hierarchy with a swipe).

fun IndirectPointerInjectionScope.pinch(
    start0: Offset,
    end0: Offset,
    start1: Offset,
    end1: Offset,
    durationMillis: Long = 400
): Unit

Performs a pinch gesture on nodes in the focus path.

For each pair of start and end Offsets, the motion events are linearly interpolated.

The coordinates are NOT in the node's local coordinate system (see IndirectPointerInjectionScope.inputDeviceSize).

The default duration is 400 milliseconds.

fun IndirectPointerInjectionScope.swipe(
    curve: (timeMillis: Long) -> Offset,
    durationMillis: Long = 200,
    keyTimes: List<Long> = emptyList()
): Unit

Performs a swipe gesture on nodes in the focus path.

The swipe follows the curve from 0 till durationMillis. Will force sampling of an event at all times defined in keyTimes. The time between events is kept as close to eventPeriodMillis as possible, given the constraints.

The coordinates are NOT in the node's local coordinate system (see IndirectPointerInjectionScope.inputDeviceSize) and is usually used for focused movement (that is, a focused node would move to the next/previous focusable node in the hierarchy with a swipe).

fun IndirectPointerInjectionScope.swipe(
    start: Offset,
    end: Offset,
    durationMillis: Long = 200
): Unit

Performs a swipe gesture on nodes in the focus path.

The motion events are linearly interpolated between start and end.

The coordinates are NOT in the node's local coordinate system (see IndirectPointerInjectionScope.inputDeviceSize) and is usually used for focused movement (that is, a focused node would move to the next/previous focusable node in the hierarchy with a swipe).

fun IndirectPointerInjectionScope.swipeDown(
    startY: Float,
    endY: Float,
    durationMillis: Long = 200
): Unit

Performs a swipe down gesture on nodes in the focus path along x = [IndirectPointerInjectionScope.inputDeviceCenter].x, from startY till endY, taking durationMillis milliseconds.

fun IndirectPointerInjectionScope.swipeLeft(
    startX: Float,
    endX: Float,
    durationMillis: Long = 200
): Unit

Performs a swipe left gesture on nodes in the focus path along y = [IndirectPointerInjectionScope.inputDeviceCenter].y, from startX till endX, taking durationMillis milliseconds.

fun IndirectPointerInjectionScope.swipeRight(
    startX: Float,
    endX: Float,
    durationMillis: Long = 200
): Unit

Performs a swipe right gesture on nodes in the focus path along y = [IndirectPointerInjectionScope.inputDeviceCenter].y, from startX till endX, taking durationMillis milliseconds.

fun IndirectPointerInjectionScope.swipeUp(
    startY: Float,
    endY: Float,
    durationMillis: Long = 200
): Unit

Performs a swipe up gesture on nodes in the focus path along x = [IndirectPointerInjectionScope.inputDeviceCenter].x, from startY till endY, taking durationMillis milliseconds.

fun IndirectPointerInjectionScope.swipeWithVelocity(
    start: Offset,
    end: Offset,
    endVelocity: @FloatRange(from = 0.0) Float,
    durationMillis: Long = VelocityPathFinder.calculateDefaultDuration(start, end, endVelocity)
): Unit

Performs a swipe gesture on nodes in the focus path such that it ends with the given endVelocity.

The swipe will go through start at t=0 and through end at t=durationMillis. In between, the swipe will go monotonically from start and end, but not strictly. Due to imprecision, no guarantees can be made for the actual velocity at the end of the gesture, but generally it is within 0.1 of the desired velocity.

When a swipe cannot be created that results in the desired velocity (because the input is too restrictive), an exception will be thrown with suggestions to fix the input.

The coordinates are NOT in the node's local coordinate system and is usually used for focused movement (that is, a focused node would move to the next focusable node in the hierarchy with a swipe).

The default duration is calculated such that a feasible swipe can be created that ends in the given velocity.

val IndirectPointerInjectionScope.inputDeviceBottom: Float

The y-coordinate for the bottom of the indirect pointer input device we're interacting with in px, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

Note that, unless inputDeviceHeight == 0, inputDeviceBottom != inputDeviceHeight. In particular, inputDeviceBottom == inputDeviceHeight - 1f, because pixels are 0-based. If inputDeviceHeight == 0, inputDeviceBottom == 0 too.

val IndirectPointerInjectionScope.inputDeviceBottomCenter: Offset

The center of the bottom edge of the indirect pointer input device we're interacting with, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

Note that inputDeviceBottomCenter.y != inputDeviceHeight, see inputDeviceBottom.

val IndirectPointerInjectionScope.inputDeviceBottomLeft: Offset

The bottom left corner of the indirect pointer input device we're interacting with, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

Note that inputDeviceBottomLeft.y != inputDeviceHeight, see inputDeviceBottom.

val IndirectPointerInjectionScope.inputDeviceBottomRight: Offset

The bottom right corner of the indirect pointer input device we're interacting with, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

Note that inputDeviceBottomRight.x != inputDeviceWidth and inputDeviceBottomRight.y != inputDeviceHeight, see inputDeviceRight and inputDeviceBottom.

val IndirectPointerInjectionScope.inputDeviceCenter: Offset

The center of the indirect pointer input device we're interacting with, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

val IndirectPointerInjectionScope.inputDeviceCenterLeft: Offset

The center of the left edge of the indirect pointer input device we're interacting with, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

val IndirectPointerInjectionScope.inputDeviceCenterRight: Offset

The center of the right edge of the indirect pointer input device we're interacting with, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

Note that inputDeviceCenterRight.x != inputDeviceWidth, see inputDeviceRight.

val IndirectPointerInjectionScope.inputDeviceCenterX: Float

The x-coordinate for the center of the indirect pointer input device we're interacting with in px, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

val IndirectPointerInjectionScope.inputDeviceCenterY: Float

The y-coordinate for the center of the indirect pointer input device we're interacting with in px, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

val IndirectPointerInjectionScope.inputDeviceHeight: Int

The height of the external indirect pointer input device that provide the height boundary for indirect input. If you go outside this height, the tests will throw an exception. Note: This is not related to the screen coordinates.

val IndirectPointerInjectionScope.inputDeviceLeft: Float

The x-coordinate for the left edge of the indirect pointer input device we're interacting with in px, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

val IndirectPointerInjectionScope.inputDeviceRight: Float

The x-coordinate for the right edge of the indirect pointer input device we're interacting with in px, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

Note that, unless inputDeviceWidth == 0, inputDeviceRight != inputDeviceWidth. In particular, inputDeviceRight == inputDeviceWidth - 1f, because pixels are 0-based. If inputDeviceWidth == 0, inputDeviceRight == 0 too.

val IndirectPointerInjectionScope.inputDeviceTop: Float

The y-coordinate for the top of the indirect pointer input device we're interacting with in px, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

val IndirectPointerInjectionScope.inputDeviceTopCenter: Offset

The center of the top edge of the indirect pointer input device we're interacting with, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

val IndirectPointerInjectionScope.inputDeviceTopLeft: Offset

The top left corner of the indirect pointer input device we're interacting with, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

val IndirectPointerInjectionScope.inputDeviceTopRight: Offset

The top right corner of the indirect pointer input device we're interacting with, where (0, 0) is the top left corner of the indirect pointer input device. Note: This is not related to the screen coordinates.

Note that inputDeviceTopRight.x != inputDeviceWidth, see inputDeviceRight.

val IndirectPointerInjectionScope.inputDeviceWidth: Int

The width of the external indirect pointer input device that provide the width boundary for indirect input. If you go outside this width, the tests will throw an exception. Note: This is not related to the screen coordinates.