ViewDragHelper

const val DIRECTION_ALL = 3: Int

Indicates that a check should occur along all axes

const val DIRECTION_HORIZONTAL = 1: Int

Indicates that a check should occur along the horizontal axis

const val DIRECTION_VERTICAL = 2: Int

Indicates that a check should occur along the vertical axis

const val EDGE_ALL = 15: Int

Edge flag set indicating all edges should be affected.

const val EDGE_BOTTOM = 8: Int

Edge flag indicating that the bottom edge should be affected.

const val EDGE_LEFT = 1: Int

Edge flag indicating that the left edge should be affected.

const val EDGE_RIGHT = 2: Int

Edge flag indicating that the right edge should be affected.

const val EDGE_TOP = 4: Int

Edge flag indicating that the top edge should be affected.

const val INVALID_POINTER = -1: Int

A null/invalid pointer ID.

const val STATE_DRAGGING = 1: Int

A view is currently being dragged. The position is currently changing as a result of user input or simulated user input.

const val STATE_IDLE = 0: Int

A view is not currently being dragged or animating as a result of a fling/snap.

const val STATE_SETTLING = 2: Int

A view is currently settling into place as a result of a fling or predefined non-interactive motion.

fun abort(): Unit

cancel, but also abort all motion in progress and snap to the end of any animation.

fun cancel(): Unit

The result of a call to this method is equivalent to processTouchEvent receiving an ACTION_CANCEL event.

fun captureChildView(childView: View, activePointerId: Int): Unit

Capture a specific child view for dragging within the parent. The callback will be notified but tryCaptureView will not be asked permission to capture this view.

fun checkTouchSlop(directions: Int): Boolean

Check if any pointer tracked in the current gesture has crossed the required slop threshold.

This depends on internal state populated by shouldInterceptTouchEvent or processTouchEvent. You should only rely on the results of this method after all currently available touch data has been provided to one of these two methods.

fun checkTouchSlop(directions: Int, pointerId: Int): Boolean

Check if the specified pointer tracked in the current gesture has crossed the required slop threshold.

This depends on internal state populated by shouldInterceptTouchEvent or processTouchEvent. You should only rely on the results of this method after all currently available touch data has been provided to one of these two methods.

fun continueSettling(deferCallbacks: Boolean): Boolean

Move the captured settling view by the appropriate amount for the current time. If continueSettling returns true, the caller should call it again on the next frame to continue.

java-static fun create(forParent: ViewGroup, cb: ViewDragHelper.Callback): ViewDragHelper

Factory method to create a new ViewDragHelper.

java-static fun create(
    forParent: ViewGroup,
    sensitivity: Float,
    cb: ViewDragHelper.Callback
): ViewDragHelper

Factory method to create a new ViewDragHelper.

fun findTopChildUnder(x: Int, y: Int): View?

Find the topmost child under the given point within the parent view's coordinate system. The child order is determined using getOrderedChildIndex.

fun flingCapturedView(minLeft: Int, minTop: Int, maxLeft: Int, maxTop: Int): Unit

Settle the captured view based on standard free-moving fling behavior. The caller should invoke continueSettling on each subsequent frame to continue the motion until it returns false.

fun getDefaultEdgeSize(): @Px Int

Return the default size used for edge tracking.

fun getEdgeSize(): @Px Int

Return the size of an edge. This is the range in pixels along the edges of this view that will actively detect edge touches or drags if edge tracking is enabled.

fun getMinVelocity(): Float

Return the currently configured minimum velocity. Any flings with a magnitude less than this value in pixels per second. Callback methods accepting a velocity will receive zero as a velocity value if the real detected velocity was below this threshold.

fun getViewDragState(): Int

Retrieve the current drag state of this helper. This will return one of STATE_IDLE, STATE_DRAGGING or STATE_SETTLING.

fun isCapturedViewUnder(x: Int, y: Int): Boolean

Determine if the currently captured view is under the given point in the parent view's coordinate system. If there is no captured view this method will return false.

fun isEdgeTouched(edges: Int): Boolean

Check if any of the edges specified were initially touched in the currently active gesture. If there is no currently active gesture this method will return false.

fun isEdgeTouched(edges: Int, pointerId: Int): Boolean

Check if any of the edges specified were initially touched by the pointer with the specified ID. If there is no currently active gesture or if there is no pointer with the given ID currently down this method will return false.

fun isPointerDown(pointerId: Int): Boolean

Check if the given pointer ID represents a pointer that is currently down (to the best of the ViewDragHelper's knowledge).

The state used to report this information is populated by the methods shouldInterceptTouchEvent or processTouchEvent. If one of these methods has not been called for all relevant MotionEvents to track, the information reported by this method may be stale or incorrect.

fun isViewUnder(view: View?, x: Int, y: Int): Boolean

Determine if the supplied view is under the given point in the parent view's coordinate system.

fun processTouchEvent(ev: MotionEvent): Unit

Process a touch event received by the parent view. This method will dispatch callback events as needed before returning. The parent view's onTouchEvent implementation should call this.

fun setEdgeSize(size: @Px @IntRange(from = 0) Int): Unit

Set the range in pixels along the edges of this view that will actively detect edge touches or drags if edge tracking is enabled.

fun setEdgeTrackingEnabled(edgeFlags: Int): Unit

Enable edge tracking for the selected edges of the parent view. The callback's onEdgeTouched and onEdgeDragStarted methods will only be invoked for edges for which edge tracking has been enabled.

fun setMinVelocity(minVel: Float): Unit

Set the minimum velocity that will be detected as having a magnitude greater than zero in pixels per second. Callback methods accepting a velocity will be clamped appropriately.

fun settleCapturedViewAt(finalLeft: Int, finalTop: Int): Boolean

Settle the captured view at the given (left, top) position. The appropriate velocity from prior motion will be taken into account. If this method returns true, the caller should invoke continueSettling on each subsequent frame to continue the motion until it returns false. If this method returns false there is no further work to do to complete the movement.

fun shouldInterceptTouchEvent(ev: MotionEvent): Boolean

Check if this event as provided to the parent view's onInterceptTouchEvent should cause the parent to intercept the touch event stream.

fun smoothSlideViewTo(child: View, finalLeft: Int, finalTop: Int): Boolean

Animate the view child to the given (left, top) position. If this method returns true, the caller should invoke continueSettling on each subsequent frame to continue the motion until it returns false. If this method returns false there is no further work to do to complete the movement.

This operation does not count as a capture event, though getCapturedView will still report the sliding view while the slide is in progress.

fun smoothSlideViewTo(
    child: View,
    finalLeft: Int,
    finalTop: Int,
    duration: Int,
    interpolator: Interpolator?
): Boolean

Animate the view child to the given (left, top) position. If this method returns true, the caller should invoke continueSettling on each subsequent frame to continue the motion until it returns false. If this method returns false there is no further work to do to complete the movement.

This operation does not count as a capture event, though getCapturedView will still report the sliding view while the slide is in progress.

protected fun canScroll(v: View, checkV: Boolean, dx: Int, dy: Int, x: Int, y: Int): Boolean

Tests scrollability within child views of v given a delta of dx.