Nivel inicial11 min de lectura · Publicado el

ScrollView en Android: cómo hacer scroll en una pantalla

ScrollView en Android: un marco fijo del tamaño de la pantalla y detrás un rollo de papel largo, su único hijo con wrap_content, que se desliza. ScrollView: un solo hijorubentejera.com ScrollViewel marcosu único hijowrap_content
El marco es el ScrollView, del tamaño de la pantalla, y el rollo es su único hijo: un layout con wrap_content de alto que mide lo que su contenido. Al deslizarlo ves lo que queda fuera del marco.

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

  1. Añade el ScrollView como hijo del layout actual.
  2. En el XML, súbelo para que sea la raíz.
  3. 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:android
  • xmlns:app
  • xmlns:tools
  • tools: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 (o LazyColumn en 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 una Column.

Ejercicio de cinco minutos

  1. 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?
  2. 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.
  3. Abre un layout de tu proyecto con ScrollView y comprueba que tiene un único hijo con wrap_content de 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 RecyclerView ni ListView dentro, NestedScrollView, fillViewport estira el contenido para llenar el hueco visible, fullScroll y smoothScrollTo), View.OnScrollChangeListener (API 23 y parámetros de onScrollChange) y Scroll en Compose (verticalScroll y LazyColumn).
  • Comprobación de lint ScrollViewSize: los hijos de un ScrollView deben usar wrap_content en 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» en addView y que el hijo se mide sin límite de alto (MeasureSpec.UNSPECIFIED).
  • Código: rangoDeScroll, haLlegadoAlFinal, sus 8 comprobaciones y el fallo sin maxOf se han compilado y ejecutado el 11 de noviembre de 2026 con kotlinc-jvm 2.4.21 y kotlin-test 2.4.21 (zip oficial de GitHub) sobre OpenJDK 25.0.5, en la imagen Docker eclipse-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.