ScrollView en Android: cómo hacer scroll en una pantalla
En Android, el ScrollView (a veces escrito scroll view) es el contenedor que permite hacer scroll de arriba abajo en una pantalla, una activity, cuando su contenido no cabe.
Funciona como un marco con un rollo de papel muy largo detrás: el marco (el ScrollView) tiene el tamaño de la pantalla y tú vas deslizando el papel (el contenido) para ver lo que queda fuera.
Las reglas del ScrollView
| Regla | Por qué |
|---|---|
| Solo un hijo directo | Si necesitas varias vistas, mételas en un layout (ConstraintLayout, LinearLayout…) y ese layout es el único hijo. |
El hijo, con wrap_content de alto |
El ScrollView deja crecer a su hijo todo lo que necesite su contenido, y eso es lo que dice wrap_content. match_parent («mide como la pantalla») dice lo contrario: Android Studio lo marca con la comprobación de lint ScrollViewSize. |
| Solo vertical | Para desplazar en horizontal existe HorizontalScrollView. |
| Nunca listas dentro | Un RecyclerView o un ListView ya tienen su propio scroll; dentro de un ScrollView van lentos y se comportan mal. |
El ConstraintLayout por sí solo no tiene scroll: por eso hay que envolverlo.
Paso a paso en Android Studio
- Añade el ScrollView como hijo del layout actual.
- En el XML, súbelo para que sea la raíz.
- Mueve los atributos de la raíz al ScrollView.
1. Añade el ScrollView
En la paleta, el ScrollView está en Containers. Si lo intentas arrastrar directamente al árbol de componentes, no te deja ponerlo como raíz (root element) en la primera posición.
La solución es insertarlo como hijo y luego, en la vista de código (la pestaña Text de entonces, hoy Code), pasarlo a la primera posición.
2. Mueve los atributos a la nueva raíz
Como ahora la raíz será el ScrollView, hay que pasarle estas cuatro propiedades que tenía el ConstraintLayout:
xmlns:androidxmlns:appxmlns:toolstools:context
Las tres primeras declaran los prefijos (android:, app:, tools:) que usa el resto del fichero; en la raíz valen para todos los elementos, también para el propio ScrollView. tools:context le dice al editor qué Activity usa este layout.
Así queda el layout con el ScrollView ya como raíz, pero con esos atributos todavía en el ConstraintLayout (código de 2018, con la Support Library; el paquete es de ejemplo). Es un paso intermedio y no compila tal cual: el ScrollView usa el prefijo android: antes de que nadie lo declare, porque xmlns:android sigue en su hijo. El editor lo subraya en rojo hasta que lo mueves:
<?xml version="1.0" encoding="utf-8"?>
<ScrollView
android:layout_height="match_parent"
android:layout_width="match_parent">
<android.support.constraint.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="com.ejemplo.scrollview.MainActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent"/>
</android.support.constraint.ConstraintLayout>
</ScrollView>
Al pasarlos al ScrollView, la raíz queda con xmlns:android, xmlns:app, xmlns:tools, sus medidas y tools:context, y el ConstraintLayout, solo con su ancho y su alto.
3. El resultado, actualizado
En el código de 2018, el ConstraintLayout tiene match_parent de alto. Cámbialo a wrap_content, que es lo que pide lint y lo que de verdad hace el ScrollView con su hijo. Si quieres que el contenido ocupe al menos toda la pantalla cuando es corto, añade android:fillViewport="true" al ScrollView.
<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fillViewport="true"
tools:context=".MainActivity">
<androidx.constraintlayout.widget.ConstraintLayout
android:layout_width="match_parent"
android:layout_height="wrap_content">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>
</ScrollView>
Un marco, un hijo, y el hijo mide lo que mida su contenido.
En Jetpack Compose
En Compose no hay un componente ScrollView: se añade el scroll a una columna con un modificador.
@Composable
fun PantallaLarga() {
Column(
modifier = Modifier
.fillMaxSize()
.verticalScroll(rememberScrollState())
) {
repeat(50) { Text("Elemento $it") }
}
}
Para listas largas, usa LazyColumn: solo dibuja los elementos que se ven, igual que hace RecyclerView con las vistas XML.
Saber cuánto se puede bajar y cuándo se llega al final
Un caso real muy habitual: una pantalla de condiciones de uso en la que el botón «Acepto» solo se activa cuando el usuario ha bajado hasta el final. Para eso necesitas dos cuentas:
- Cuánto se puede desplazar (el rango): lo que mide el hijo menos el hueco visible del ScrollView. Si el contenido cabe, el rango es 0.
- Si ya ha llegado al final: la posición actual (
scrollY) es igual o mayor que el rango.
El código fuente de Android (AOSP) calcula el rango en ScrollView.getScrollRange() así: el máximo entre 0 y el alto del hijo menos el alto del ScrollView sin su padding. La misma cuenta, en Kotlin puro y con su test, se puede probar sin emulador:
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
// Medidas en píxeles. Misma cuenta que ScrollView.getScrollRange() en AOSP.
fun rangoDeScroll(altoHijo: Int, altoScroll: Int, paddingArriba: Int = 0, paddingAbajo: Int = 0): Int =
maxOf(0, altoHijo - (altoScroll - paddingArriba - paddingAbajo))
// ¿Ha llegado el usuario al final? margen: cuántos píxeles de tolerancia
fun haLlegadoAlFinal(scrollY: Int, rango: Int, margen: Int = 0): Boolean =
scrollY >= rango - margen
fun main() {
// Contenido de 3000 px en una pantalla de 2000 px: se puede bajar 1000 px
assertEquals(1000, rangoDeScroll(altoHijo = 3000, altoScroll = 2000))
// Con 50 px de padding arriba y abajo, queda menos hueco y hay más que bajar
assertEquals(1100, rangoDeScroll(3000, 2000, paddingArriba = 50, paddingAbajo = 50))
// Contenido corto: no hay nada que desplazar, nunca un rango negativo
assertEquals(0, rangoDeScroll(altoHijo = 800, altoScroll = 2000))
assertFalse(haLlegadoAlFinal(scrollY = 0, rango = 1000), "arriba del todo")
assertFalse(haLlegadoAlFinal(scrollY = 999, rango = 1000), "a 1 px del final")
assertTrue(haLlegadoAlFinal(scrollY = 1000, rango = 1000), "al final")
assertTrue(haLlegadoAlFinal(scrollY = 980, rango = 1000, margen = 24), "casi al final, con margen")
assertTrue(haLlegadoAlFinal(scrollY = 0, rango = 0), "si no hay scroll, ya está al final")
println("8 comprobaciones superadas")
}
Se compila con kotlinc y kotlin-test, la biblioteca de aserciones que viene en su zip oficial. Las órdenes suponen kotlinc en el PATH y el zip oficial del compilador descomprimido en ./kotlinc, que es de donde sale kotlin-test.jar:
kotlinc Desplazamiento.kt -cp kotlinc/lib/kotlin-test.jar -include-runtime -d desplazamiento.jar
java -cp desplazamiento.jar:kotlinc/lib/kotlin-test.jar DesplazamientoKt
8 comprobaciones superadas
Si quitas el maxOf(0, …), un contenido corto da un rango negativo, y el test lo detecta:
Exception in thread "main" java.lang.AssertionError: Expected <0>, actual <-1200>.
La última comprobación importa: si las condiciones son cortas y caben en la pantalla, el usuario no puede bajar, así que el botón debe activarse sin esperar a un scroll que nunca llegará.
En la activity, el listener solo traduce las medidas de Android a esas funciones. setOnScrollChangeListener existe en cualquier vista desde la API 23. [SIN EJECUTAR], como el resto del código de Android de este artículo:
val scroll = findViewById<ScrollView>(R.id.scrollCondiciones)
val acepto = findViewById<Button>(R.id.botonAcepto)
fun actualizarBoton() {
val rango = rangoDeScroll(
altoHijo = scroll.getChildAt(0).height,
altoScroll = scroll.height,
paddingArriba = scroll.paddingTop,
paddingAbajo = scroll.paddingBottom,
)
acepto.isEnabled = haLlegadoAlFinal(scroll.scrollY, rango, margen = 24)
}
scroll.setOnScrollChangeListener { _, _, _, _, _ -> actualizarBoton() }
scroll.post { actualizarBoton() } // cuando ya está medido, por si el texto cabe entero
El margen de 24 px es una tolerancia para no exigir el último píxel; los píxeles cambian de un móvil a otro, así que en una app real conviene convertir dp a píxeles con resources.displayMetrics.density.
Errores frecuentes
1. «ScrollView can host only one direct child»
Si pones dos vistas directamente dentro del ScrollView, la app se cierra al abrir la pantalla. El mensaje está en el código fuente de ScrollView (AOSP), en cada variante de addView:
java.lang.IllegalStateException: ScrollView can host only one direct child
[SIN EJECUTAR]: el texto sale del código fuente, no de una ejecución en un móvil. Como el layout se infla desde XML, en el registro de la app la excepción suele aparecer envuelta en una android.view.InflateException: Binary XML file line #…, con este mensaje debajo, tras «Caused by:». Se arregla envolviendo las vistas en un único layout, como en el paso a paso.
2. Un RecyclerView o un ListView dentro
La documentación de ScrollView es tajante: no lo hagas nunca, porque el rendimiento y la experiencia de uso son malos. Cada lista ya tiene su propio scroll, y dentro de otro los dos se pelean por el mismo gesto. Si necesitas una cabecera encima de una lista, ponla como primer elemento de la lista o usa ConcatAdapter con el RecyclerView.
3. Esperar que fillViewport haga scroll
android:fillViewport="true" no añade scroll: según la documentación, estira el contenido para que llene el hueco visible cuando es más corto. Sirve, por ejemplo, para que un botón anclado abajo del ConstraintLayout quede al pie de la pantalla aunque haya poco texto.
4. Desplazar antes de que la vista esté medida
En onCreate, las vistas todavía no tienen tamaño: height vale 0 y un scrollTo o un fullScroll(View.FOCUS_DOWN) no tienen hacia dónde ir. Haz esas llamadas dentro de scroll.post { … }, que se ejecuta después, como en el ejemplo de arriba.
5. Usar ScrollView para desplazar en horizontal
ScrollView solo desplaza en vertical. Para horizontal existe HorizontalScrollView, con las mismas reglas: un único hijo, esta vez con wrap_content de ancho.
Cuándo no usar ScrollView
- Para listas largas o que crecen. Un ScrollView crea y mide todo su contenido de golpe, aunque solo se vea una parte. Para cien productos o un chat,
RecyclerView(oLazyColumnen Compose), que solo crea lo que se ve. - Si la pantalla usa barras que se esconden al hacer scroll u otros patrones de Material Design:
NestedScrollView, que se usa igual. - En pantallas nuevas con Compose. No hay ScrollView:
Modifier.verticalScroll(rememberScrollState())en unaColumn.
Ejercicio de cinco minutos
- Añade al test el caso de una pantalla de 2000 px con un contenido de exactamente 2000 px. ¿Qué rango esperas? ¿Debe activarse el botón «Acepto» sin bajar?
- Escribe una función
porcentajeLeido(scrollY, rango)que devuelva de 0 a 100, pruébala con 0, 500 y 1000 sobre un rango de 1000 y decide qué debe devolver con rango 0 antes de implementarla. - Abre un layout de tu proyecto con ScrollView y comprueba que tiene un único hijo con
wrap_contentde alto y ninguna lista dentro.
Si estás empezando con Android, te puede venir bien Hola mundo con Android Studio y Kotlin o entender el ciclo de vida de las Activities.
Fuentes
Consultadas el 11 de noviembre de 2026.
- Documentación oficial de Android: ScrollView (un único hijo, solo vertical, nunca
RecyclerViewniListViewdentro,NestedScrollView,fillViewportestira el contenido para llenar el hueco visible,fullScrollysmoothScrollTo), View.OnScrollChangeListener (API 23 y parámetros deonScrollChange) y Scroll en Compose (verticalScrollyLazyColumn). - Comprobación de lint ScrollViewSize: los hijos de un ScrollView deben usar
wrap_contenten el eje del scroll. - Código fuente de Android (AOSP), ScrollView.java en la rama main:
getScrollRange(), el mensaje «ScrollView can host only one direct child» enaddViewy que el hijo se mide sin límite de alto (MeasureSpec.UNSPECIFIED). - Código:
rangoDeScroll,haLlegadoAlFinal, sus 8 comprobaciones y el fallo sinmaxOfse han compilado y ejecutado el 11 de noviembre de 2026 conkotlinc-jvm2.4.21 ykotlin-test2.4.21 (zip oficial de GitHub) sobre OpenJDK 25.0.5, en la imagen Dockereclipse-temurin:25. - El XML de 2018 es el del artículo original, con un paquete de ejemplo. El XML actualizado, el listener de la activity y el ejemplo de Compose están
[SIN EJECUTAR](requieren un proyecto Android): se han contrastado con esa documentación y con el código fuente.