En Android, el desplazamiento generalmente se logra usando el
ScrollView
. Anida cualquier diseño estándar que pueda extenderse más allá de los límites de su
contenedor en un ScrollView
para proporcionar una vista desplazable administrada por
en el framework. La implementación de un desplazador personalizado solo es necesaria
reales. En este documento, se describe cómo mostrar un efecto de desplazamiento en respuesta
gestos táctiles con desplazadores.
Tu app puede usar
desplazadores: Scroller
o
OverScroller
a
recopilar los datos necesarios para producir una animación de desplazamiento en respuesta a un toque
para cada evento. Son similares, pero OverScroller
también incluye métodos para
Indicar a los usuarios cuándo llegan al borde del contenido después de un desplazamiento lateral o deslizado
gesto.
- A partir de Android 12 (nivel de API 31), los elementos visuales se estiran y rebotan a un evento de arrastre y a un evento de deslizamiento y rebota hacia atrás en él.
- En Android 11 (nivel de API 30) y versiones anteriores, los límites muestran un "resplandor" efecto después de un gesto de arrastrar o arrastrar al borde.
En la muestra de InteractiveChart
de este documento, se usa el
EdgeEffect
para mostrar estos efectos de sobredesplazamiento.
Puedes usar un desplazador para animar el desplazamiento con el paso del tiempo usando física de desplazamiento estándar de la plataforma, como la fricción, la velocidad y otras cualidades. La barra de desplazamiento no dibuja nada. Los desplazadores hacen un seguimiento del desplazamiento compensaciones para ti con el paso del tiempo, pero no aplican esas posiciones automáticamente a tu vista. Debes obtener y aplicar nuevas coordenadas a una velocidad que haga que la animación de desplazamiento se vea suave.
Cómo interpretar la terminología de desplazamiento
Desplazamiento es una palabra que puede tener distintos significados en Android, dependiendo de el contexto.
El desplazamiento es el proceso general de mover el viewport, es decir,
la "ventana" del contenido que ves. Cuando el desplazamiento se realiza tanto en
los ejes x e y, se llama desplazamiento lateral. El
La app de ejemplo de InteractiveChart
en este documento ilustra dos
diferentes tipos de desplazamiento, arrastre y deslizamiento:
- Arrastrar: Es el tipo de desplazamiento que ocurre cuando un usuario.
arrastra el dedo por la pantalla táctil. Puedes implementar la función Arrastrar por
anulando
onScroll()
enGestureDetector.OnGestureListener
Para obtener más información sobre el arrastre, consulta Arrastrar y ajustar - Arrastrar y soltar: Es el tipo de desplazamiento que ocurre cuando un usuario
arrastra y levanta el dedo rápidamente. Después de que el usuario levante el dedo,
generalmente quieres seguir moviendo la viewport, pero desacelerar hasta
viewport deja de moverse. Puedes implementar el deslizamiento si anulas
onFling()
enGestureDetector.OnGestureListener
y con una barra de desplazamiento . - Desplazamiento lateral: desplazarse simultáneamente a lo largo de las líneas x y Los ejes y se llaman desplazamiento lateral.
Es común usar objetos desplazadores junto con un gesto de arrastrar y soltar, pero
puedes usarlos en cualquier contexto en el que desees que la IU muestre el desplazamiento.
respuesta a un evento táctil. Por ejemplo, puedes anular
onTouchEvent()
para procesar eventos táctiles directamente y producir un efecto de desplazamiento o una
"ajustar a la página" animación en respuesta a esos eventos táctiles.
Componentes que contienen implementaciones de desplazamiento integradas
Los siguientes componentes de Android contienen compatibilidad integrada para el desplazamiento y comportamiento de sobredesplazamiento:
GridView
HorizontalScrollView
ListView
NestedScrollView
RecyclerView
ScrollView
ViewPager
ViewPager2
Si tu app necesita admitir el desplazamiento y el sobredesplazamiento dentro de un completa los siguientes pasos:
- Cómo crear un desplazamiento táctil personalizado implementación.
- Para admitir dispositivos que ejecutan Android 12 y versiones posteriores, haz lo siguiente: implemente el sobredesplazamiento de estiramiento efecto.
Cómo crear una implementación personalizada de desplazamiento basado en el tacto
En esta sección, se describe cómo crear tu propio desplazador si tu app usa una un componente que no pueden tener compatibilidad integrada con el desplazamiento y el sobredesplazamiento.
El siguiente fragmento proviene de la
InteractiveChart
muestra. Utiliza un
GestureDetector
y anula el
GestureDetector.SimpleOnGestureListener
método onFling()
. Usa OverScroller
para hacer un seguimiento
de arrastrar y soltar. Si el usuario llega al límite del contenido después de realizar
gesto de lanzamiento, el contenedor indica cuando el usuario llega al final de
contenido. La indicación depende de la versión de Android que tenga un dispositivo
ejecuta el siguiente comando:
- En Android 12 y versiones posteriores, los elementos visuales se estiran y recuperarse.
- En Android 11 y versiones anteriores, los elementos visuales muestran un brillo efecto.
La primera parte del siguiente fragmento muestra la implementación de
onFling()
:
Kotlin
// Viewport extremes. See currentViewport for a discussion of the viewport. private val AXIS_X_MIN = -1f private val AXIS_X_MAX = 1f private val AXIS_Y_MIN = -1f private val AXIS_Y_MAX = 1f // The current viewport. This rectangle represents the visible chart // domain and range. The viewport is the part of the app that the // user manipulates via touch gestures. private val currentViewport = RectF(AXIS_X_MIN, AXIS_Y_MIN, AXIS_X_MAX, AXIS_Y_MAX) // The current destination rectangle—in pixel coordinates—into which // the chart data must be drawn. private lateinit var contentRect: Rect private lateinit var scroller: OverScroller private lateinit var scrollerStartViewport: RectF ... private val gestureListener = object : GestureDetector.SimpleOnGestureListener() { override fun onDown(e: MotionEvent): Boolean { // Initiates the decay phase of any active edge effects. if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) { releaseEdgeEffects() } scrollerStartViewport.set(currentViewport) // Aborts any active scroll animations and invalidates. scroller.forceFinished(true) ViewCompat.postInvalidateOnAnimation(this@InteractiveLineGraphView) return true } ... override fun onFling( e1: MotionEvent, e2: MotionEvent, velocityX: Float, velocityY: Float ): Boolean { fling((-velocityX).toInt(), (-velocityY).toInt()) return true } } private fun fling(velocityX: Int, velocityY: Int) { // Initiates the decay phase of any active edge effects. // On Android 12 and later, the edge effect (stretch) must // continue. if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) { releaseEdgeEffects() } // Flings use math in pixels, as opposed to math based on the viewport. val surfaceSize: Point = computeScrollSurfaceSize() val (startX: Int, startY: Int) = scrollerStartViewport.run { set(currentViewport) (surfaceSize.x * (left - AXIS_X_MIN) / (AXIS_X_MAX - AXIS_X_MIN)).toInt() to (surfaceSize.y * (AXIS_Y_MAX - bottom) / (AXIS_Y_MAX - AXIS_Y_MIN)).toInt() } // Before flinging, stops the current animation. scroller.forceFinished(true) // Begins the animation. scroller.fling( // Current scroll position. startX, startY, velocityX, velocityY, /* * Minimum and maximum scroll positions. The minimum scroll * position is generally 0 and the maximum scroll position * is generally the content size less the screen size. So if the * content width is 1000 pixels and the screen width is 200 * pixels, the maximum scroll offset is 800 pixels. */ 0, surfaceSize.x - contentRect.width(), 0, surfaceSize.y - contentRect.height(), // The edges of the content. This comes into play when using // the EdgeEffect class to draw "glow" overlays. contentRect.width() / 2, contentRect.height() / 2 ) // Invalidates to trigger computeScroll(). ViewCompat.postInvalidateOnAnimation(this) }
Java
// Viewport extremes. See currentViewport for a discussion of the viewport. private static final float AXIS_X_MIN = -1f; private static final float AXIS_X_MAX = 1f; private static final float AXIS_Y_MIN = -1f; private static final float AXIS_Y_MAX = 1f; // The current viewport. This rectangle represents the visible chart // domain and range. The viewport is the part of the app that the // user manipulates via touch gestures. private RectF currentViewport = new RectF(AXIS_X_MIN, AXIS_Y_MIN, AXIS_X_MAX, AXIS_Y_MAX); // The current destination rectangle—in pixel coordinates—into which // the chart data must be drawn. private final Rect contentRect = new Rect(); private final OverScroller scroller; private final RectF scrollerStartViewport = new RectF(); // Used only for zooms and flings. ... private final GestureDetector.SimpleOnGestureListener gestureListener = new GestureDetector.SimpleOnGestureListener() { @Override public boolean onDown(MotionEvent e) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) { releaseEdgeEffects(); } scrollerStartViewport.set(currentViewport); scroller.forceFinished(true); ViewCompat.postInvalidateOnAnimation(InteractiveLineGraphView.this); return true; } ... @Override public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { fling((int) -velocityX, (int) -velocityY); return true; } }; private void fling(int velocityX, int velocityY) { // Initiates the decay phase of any active edge effects. // On Android 12 and later, the edge effect (stretch) must // continue. if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) { releaseEdgeEffects(); } // Flings use math in pixels, as opposed to math based on the viewport. Point surfaceSize = computeScrollSurfaceSize(); scrollerStartViewport.set(currentViewport); int startX = (int) (surfaceSize.x * (scrollerStartViewport.left - AXIS_X_MIN) / ( AXIS_X_MAX - AXIS_X_MIN)); int startY = (int) (surfaceSize.y * (AXIS_Y_MAX - scrollerStartViewport.bottom) / ( AXIS_Y_MAX - AXIS_Y_MIN)); // Before flinging, stops the current animation. scroller.forceFinished(true); // Begins the animation. scroller.fling( // Current scroll position. startX, startY, velocityX, velocityY, /* * Minimum and maximum scroll positions. The minimum scroll * position is generally 0 and the maximum scroll position * is generally the content size less the screen size. So if the * content width is 1000 pixels and the screen width is 200 * pixels, the maximum scroll offset is 800 pixels. */ 0, surfaceSize.x - contentRect.width(), 0, surfaceSize.y - contentRect.height(), // The edges of the content. This comes into play when using // the EdgeEffect class to draw "glow" overlays. contentRect.width() / 2, contentRect.height() / 2); // Invalidates to trigger computeScroll(). ViewCompat.postInvalidateOnAnimation(this); }
Cuando llame a onFling()
postInvalidateOnAnimation()
,
se activa
computeScroll()
para actualizar los valores de x e y. Esto suele hacerse cuando un
vista secundaria está animando un desplazamiento con un objeto desplazador, como se muestra en la diapositiva anterior
ejemplo.
La mayoría de las vistas pasan la posición x e y del objeto de desplazamiento directamente.
a
scrollTo()
La siguiente implementación de computeScroll()
toma un cambio
enfoque: llama
computeScrollOffset()
para obtener la ubicación actual de x e y. Cuando los criterios para
mostrar un “resplandor” de sobredesplazamiento el efecto de borde, es decir, la pantalla
esté acercada, x o y estén fuera de los límites y la app aún no esté
que muestra un sobredesplazamiento (el código configura el efecto de resplandor y
llama a postInvalidateOnAnimation()
para activar una invalidación en el
vista.
Kotlin
// Edge effect/overscroll tracking objects. private lateinit var edgeEffectTop: EdgeEffect private lateinit var edgeEffectBottom: EdgeEffect private lateinit var edgeEffectLeft: EdgeEffect private lateinit var edgeEffectRight: EdgeEffect private var edgeEffectTopActive: Boolean = false private var edgeEffectBottomActive: Boolean = false private var edgeEffectLeftActive: Boolean = false private var edgeEffectRightActive: Boolean = false override fun computeScroll() { super.computeScroll() var needsInvalidate = false // The scroller isn't finished, meaning a fling or // programmatic pan operation is active. if (scroller.computeScrollOffset()) { val surfaceSize: Point = computeScrollSurfaceSize() val currX: Int = scroller.currX val currY: Int = scroller.currY val (canScrollX: Boolean, canScrollY: Boolean) = currentViewport.run { (left > AXIS_X_MIN || right < AXIS_X_MAX) to (top > AXIS_Y_MIN || bottom < AXIS_Y_MAX) } /* * If you are zoomed in, currX or currY is * outside of bounds, and you aren't already * showing overscroll, then render the overscroll * glow edge effect. */ if (canScrollX && currX < 0 && edgeEffectLeft.isFinished && !edgeEffectLeftActive) { edgeEffectLeft.onAbsorb(scroller.currVelocity.toInt()) edgeEffectLeftActive = true needsInvalidate = true } else if (canScrollX && currX > surfaceSize.x - contentRect.width() && edgeEffectRight.isFinished && !edgeEffectRightActive) { edgeEffectRight.onAbsorb(scroller.currVelocity.toInt()) edgeEffectRightActive = true needsInvalidate = true } if (canScrollY && currY < 0 && edgeEffectTop.isFinished && !edgeEffectTopActive) { edgeEffectTop.onAbsorb(scroller.currVelocity.toInt()) edgeEffectTopActive = true needsInvalidate = true } else if (canScrollY && currY > surfaceSize.y - contentRect.height() && edgeEffectBottom.isFinished && !edgeEffectBottomActive) { edgeEffectBottom.onAbsorb(scroller.currVelocity.toInt()) edgeEffectBottomActive = true needsInvalidate = true } ... } }
Java
// Edge effect/overscroll tracking objects. private EdgeEffectCompat edgeEffectTop; private EdgeEffectCompat edgeEffectBottom; private EdgeEffectCompat edgeEffectLeft; private EdgeEffectCompat edgeEffectRight; private boolean edgeEffectTopActive; private boolean edgeEffectBottomActive; private boolean edgeEffectLeftActive; private boolean edgeEffectRightActive; @Override public void computeScroll() { super.computeScroll(); boolean needsInvalidate = false; // The scroller isn't finished, meaning a fling or // programmatic pan operation is active. if (scroller.computeScrollOffset()) { Point surfaceSize = computeScrollSurfaceSize(); int currX = scroller.getCurrX(); int currY = scroller.getCurrY(); boolean canScrollX = (currentViewport.left > AXIS_X_MIN || currentViewport.right < AXIS_X_MAX); boolean canScrollY = (currentViewport.top > AXIS_Y_MIN || currentViewport.bottom < AXIS_Y_MAX); /* * If you are zoomed in, currX or currY is * outside of bounds, and you aren't already * showing overscroll, then render the overscroll * glow edge effect. */ if (canScrollX && currX < 0 && edgeEffectLeft.isFinished() && !edgeEffectLeftActive) { edgeEffectLeft.onAbsorb((int)mScroller.getCurrVelocity()); edgeEffectLeftActive = true; needsInvalidate = true; } else if (canScrollX && currX > (surfaceSize.x - contentRect.width()) && edgeEffectRight.isFinished() && !edgeEffectRightActive) { edgeEffectRight.onAbsorb((int)mScroller.getCurrVelocity()); edgeEffectRightActive = true; needsInvalidate = true; } if (canScrollY && currY < 0 && edgeEffectTop.isFinished() && !edgeEffectTopActive) { edgeEffectRight.onAbsorb((int)mScroller.getCurrVelocity()); edgeEffectTopActive = true; needsInvalidate = true; } else if (canScrollY && currY > (surfaceSize.y - contentRect.height()) && edgeEffectBottom.isFinished() && !edgeEffectBottomActive) { edgeEffectRight.onAbsorb((int)mScroller.getCurrVelocity()); edgeEffectBottomActive = true; needsInvalidate = true; } ... }
La siguiente es la sección del código que realiza el zoom real:
Kotlin
lateinit var zoomer: Zoomer val zoomFocalPoint = PointF() ... // If a zoom is in progress—either programmatically // or through double touch—this performs the zoom. if (zoomer.computeZoom()) { val newWidth: Float = (1f - zoomer.currZoom) * scrollerStartViewport.width() val newHeight: Float = (1f - zoomer.currZoom) * scrollerStartViewport.height() val pointWithinViewportX: Float = (zoomFocalPoint.x - scrollerStartViewport.left) / scrollerStartViewport.width() val pointWithinViewportY: Float = (zoomFocalPoint.y - scrollerStartViewport.top) / scrollerStartViewport.height() currentViewport.set( zoomFocalPoint.x - newWidth * pointWithinViewportX, zoomFocalPoint.y - newHeight * pointWithinViewportY, zoomFocalPoint.x + newWidth * (1 - pointWithinViewportX), zoomFocalPoint.y + newHeight * (1 - pointWithinViewportY) ) constrainViewport() needsInvalidate = true } if (needsInvalidate) { ViewCompat.postInvalidateOnAnimation(this) }
Java
// Custom object that is functionally similar to Scroller. Zoomer zoomer; private PointF zoomFocalPoint = new PointF(); ... // If a zoom is in progress—either programmatically // or through double touch—this performs the zoom. if (zoomer.computeZoom()) { float newWidth = (1f - zoomer.getCurrZoom()) * scrollerStartViewport.width(); float newHeight = (1f - zoomer.getCurrZoom()) * scrollerStartViewport.height(); float pointWithinViewportX = (zoomFocalPoint.x - scrollerStartViewport.left) / scrollerStartViewport.width(); float pointWithinViewportY = (zoomFocalPoint.y - scrollerStartViewport.top) / scrollerStartViewport.height(); currentViewport.set( zoomFocalPoint.x - newWidth * pointWithinViewportX, zoomFocalPoint.y - newHeight * pointWithinViewportY, zoomFocalPoint.x + newWidth * (1 - pointWithinViewportX), zoomFocalPoint.y + newHeight * (1 - pointWithinViewportY)); constrainViewport(); needsInvalidate = true; } if (needsInvalidate) { ViewCompat.postInvalidateOnAnimation(this); }
Este es el método computeScrollSurfaceSize()
al que se llama en
el fragmento anterior. Calcula el tamaño actual de la superficie desplazable en
píxeles. Por ejemplo, si toda el área del gráfico es visible, esta es la configuración
un tamaño de mContentRect
. Si el gráfico se acerca al 200% en ambos
en instrucciones sobre cómo llegar, el tamaño que se muestra es el doble en sentido horizontal y vertical.
Kotlin
private fun computeScrollSurfaceSize(): Point { return Point( (contentRect.width() * (AXIS_X_MAX - AXIS_X_MIN) / currentViewport.width()).toInt(), (contentRect.height() * (AXIS_Y_MAX - AXIS_Y_MIN) / currentViewport.height()).toInt() ) }
Java
private Point computeScrollSurfaceSize() { return new Point( (int) (contentRect.width() * (AXIS_X_MAX - AXIS_X_MIN) / currentViewport.width()), (int) (contentRect.height() * (AXIS_Y_MAX - AXIS_Y_MIN) / currentViewport.height())); }
Para ver otro ejemplo de uso de desplazamiento, consulta el
código fuente
para la clase ViewPager
. Se desplaza en respuesta a desplazamientos y usos
y el desplazamiento para implementar el menú "ajustar a la página" animación.
Implementa el efecto de sobredesplazamiento de estiramiento
A partir de Android 12, EdgeEffect
agrega lo siguiente:
las siguientes APIs para implementar el efecto de sobredesplazamiento de estiramiento:
getDistance()
onPullDistance()
Para proporcionar la mejor experiencia del usuario con el sobredesplazamiento extendido, haz lo siguiente: lo siguiente:
- Cuando la animación de estiramiento está activa cuando el usuario toca registra el toque como una "captura". El usuario detiene la animación y empiece a manipular el estiramiento nuevamente.
- Cuando el usuario mueva el dedo en la dirección opuesta al estiramiento, suelta el estiramiento hasta que desaparezca por completo y, luego, comienza a desplazarte.
- Cuando el usuario desliza el dedo durante un estiramiento, desplaza el
EdgeEffect
. para mejorar el efecto de estiramiento.
Captura la animación
Cuando un usuario captura una animación de estiramiento activa,
EdgeEffect.getDistance()
muestra 0
. Esta condición
indica que el estiramiento debe manipularse con movimiento táctil. En la mayoría
contenedores, el catch se detecta en onInterceptTouchEvent()
, como
se muestra en el siguiente fragmento de código:
Kotlin
override fun onInterceptTouchEvent(ev: MotionEvent): Boolean { ... when (action and MotionEvent.ACTION_MASK) { MotionEvent.ACTION_DOWN -> ... isBeingDragged = EdgeEffectCompat.getDistance(edgeEffectBottom) > 0f || EdgeEffectCompat.getDistance(edgeEffectTop) > 0f ... } return isBeingDragged }
Java
@Override public boolean onInterceptTouchEvent(MotionEvent ev) { ... switch (action & MotionEvent.ACTION_MASK) { case MotionEvent.ACTION_DOWN: ... isBeingDragged = EdgeEffectCompat.getDistance(edgeEffectBottom) > 0 || EdgeEffectCompat.getDistance(edgeEffectTop) > 0; ... } }
En el ejemplo anterior, onInterceptTouchEvent()
muestra
true
cuando mIsBeingDragged
es true
, así que
permite consumir el evento antes de que el elemento secundario
y consumirlo.
Libera el efecto de sobredesplazamiento
Es importante liberar el efecto de estiramiento antes de desplazarse para evitar el estiramiento se aplique al contenido de desplazamiento. El siguiente código de muestra aplica esta práctica recomendada:
Kotlin
override fun onTouchEvent(ev: MotionEvent): Boolean { val activePointerIndex = ev.actionIndex when (ev.getActionMasked()) { MotionEvent.ACTION_MOVE -> val x = ev.getX(activePointerIndex) val y = ev.getY(activePointerIndex) var deltaY = y - lastMotionY val pullDistance = deltaY / height val displacement = x / width if (deltaY < 0f && EdgeEffectCompat.getDistance(edgeEffectTop) > 0f) { deltaY -= height * EdgeEffectCompat.onPullDistance(edgeEffectTop, pullDistance, displacement); } if (deltaY > 0f && EdgeEffectCompat.getDistance(edgeEffectBottom) > 0f) { deltaY += height * EdgeEffectCompat.onPullDistance(edgeEffectBottom, -pullDistance, 1 - displacement); } ... }
Java
@Override public boolean onTouchEvent(MotionEvent ev) { final int actionMasked = ev.getActionMasked(); switch (actionMasked) { case MotionEvent.ACTION_MOVE: final float x = ev.getX(activePointerIndex); final float y = ev.getY(activePointerIndex); float deltaY = y - lastMotionY; float pullDistance = deltaY / getHeight(); float displacement = x / getWidth(); if (deltaY < 0 && EdgeEffectCompat.getDistance(edgeEffectTop) > 0) { deltaY -= getHeight() * EdgeEffectCompat.onPullDistance(edgeEffectTop, pullDistance, displacement); } if (deltaY > 0 && EdgeEffectCompat.getDistance(edgeEffectBottom) > 0) { deltaY += getHeight() * EdgeEffectCompat.onPullDistance(edgeEffectBottom, -pullDistance, 1 - displacement); } ...
Cuando el usuario arrastra, consume la distancia de extracción de EdgeEffect
.
antes de pasar el evento táctil a un contenedor de desplazamiento anidado o arrastrar el
desplazar. En la muestra de código anterior, getDistance()
muestra un
positivo cuando se muestra un efecto de borde y puede liberarse con
o movimiento. Cuando el evento táctil libera el estiramiento, primero lo consume el
EdgeEffect
para que se lance por completo antes que otros efectos,
como el desplazamiento anidado. Puedes usar getDistance()
para saber cuánta distancia tirar se requiere para liberar el efecto actual.
A diferencia de onPull()
, onPullDistance()
muestra el
y consumida del delta que se pasó. A partir de Android 12, si
onPull()
o onPullDistance()
tienen resultados negativos.
Valores deltaDistance
cuando getDistance()
es
0
, el efecto de estiramiento no cambia. En Android 11
y anteriores, onPull()
permite valores negativos para la distancia total
para mostrar efectos de brillo.
Cómo inhabilitar el sobredesplazamiento
Puedes inhabilitar el sobredesplazamiento en el archivo de diseño o de manera programática.
Para inhabilitar el archivo de diseño, establece android:overScrollMode
como
como se muestra en el siguiente ejemplo:
<MyCustomView android:overScrollMode="never"> ... </MyCustomView>
Para inhabilitar esta opción de forma programática, usa un código como el siguiente:
Kotlin
customView.overScrollMode = View.OVER_SCROLL_NEVER
Java
customView.setOverScrollMode(View.OVER_SCROLL_NEVER);
Recursos adicionales
Consulta los siguientes recursos relacionados:
- Descripción general de eventos de entrada
- Descripción general de los sensores
- Cómo crear una vista personalizada interactiva