Nivel inicial10 min de lectura · Publicado el

Toast y Snackbar en Android: cuándo usar cada uno

Toast y Snackbar en Android: el Toast «Hello from the Toast» flota sobre la pantalla; el Snackbar «Hello from the SnackBar!» sale abajo con UNDO. Toast avisa, Snackbar actúarubentejera.com Hello fromthe ToastHello fromthe SnackBar!UNDOToastSnackbar
El Toast es un mensaje corto que flota un momento y desaparece, sin botones. El Snackbar sale abajo, dentro de tu pantalla, y puede llevar una acción con setAction, como este UNDO para deshacer.

Un Snackbar en Android (a veces escrito snack bar) es una barra con un mensaje corto que aparece en la parte de abajo de la pantalla y puede llevar un botón para reaccionar, como «Deshacer». Hoy se muestra de dos formas: con Jetpack Compose, el sistema de interfaz que Android recomienda, o con Views (layouts XML) y Material Components. El Toast es su pariente más simple: un aviso flotante sin botones.

Toast vs Snackbar en Android: la diferencia

Toast Snackbar
Dónde sale Flotando sobre la pantalla Abajo, dentro de la pantalla de tu app
Botón de acción No Sí, uno
Se puede descartar No, desaparece solo Sí, con un botón de cerrar o, en Views dentro de un CoordinatorLayout, deslizándolo
Dependencia Ninguna, es parte de Android Material 3 para Compose, Material Components para Views
Duración LENGTH_SHORT o LENGTH_LONG Corta, larga o indefinida, hasta que el usuario actúe
Personalizar su aspecto Ya no: las vistas personalizadas de Toast están obsoletas desde Android 11 (API 30) Sí

La tabla es explicación nuestra a partir de la documentación de Android. La recomendación oficial es directa: si tu app está en primer plano, la guía de Toasts propone usar un Snackbar en su lugar, porque permite al usuario actuar. Si la app está en segundo plano y necesitas que el usuario haga algo, lo adecuado es una notificación.

Snackbar en Jetpack Compose

En Compose el Snackbar se monta con tres piezas, que el Scaffold (la estructura básica de una pantalla de Material 3) une:

  1. SnackbarHostState: el estado que guarda qué Snackbar se está mostrando y cuáles esperan su turno. Se crea con remember para que sobreviva a las recomposiciones (cada vez que Compose vuelve a dibujar la pantalla).
  2. SnackbarHost: el sitio de la pantalla donde aparece el Snackbar. Se pasa al parámetro snackbarHost del Scaffold.
  3. showSnackbar(): la función que lo muestra. Es una función suspend, así que se llama dentro de una corrutina, un bloque de código que puede quedarse esperando sin congelar la pantalla, normalmente con el CoroutineScope de rememberCoroutineScope().

1. Añade la dependencia

Material 3 para Compose, en el build.gradle.kts del módulo, con la BOM (la lista de versiones compatibles de Compose):

dependencies {
    implementation(platform("androidx.compose:compose-bom:2026.09.00"))
    implementation("androidx.compose.material3:material3")
}

La BOM 2026.09.00 fija Material 3 en la versión 1.4.0, la última estable en noviembre de 2026 según el repositorio Maven de Google. Si tu proyecto ya usa Compose, lo normal es que ya la tengas.

2. Muestra un Snackbar con acción

Este ejemplo junta lo que muestra la documentación oficial: un botón que archiva un correo y enseña un Snackbar con «Deshacer». showSnackbar() espera hasta que el Snackbar desaparece y devuelve un SnackbarResult que dice qué pasó.

import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarDuration
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.SnackbarResult
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.ui.Modifier
import kotlinx.coroutines.launch

@Composable
fun PantallaCorreo() {
    val snackbarHostState = remember { SnackbarHostState() }
    val scope = rememberCoroutineScope()

    Scaffold(
        snackbarHost = { SnackbarHost(hostState = snackbarHostState) }
    ) { innerPadding ->
        Button(
            modifier = Modifier.padding(innerPadding),
            onClick = {
                scope.launch {
                    val resultado = snackbarHostState.showSnackbar(
                        message = "Correo archivado",
                        actionLabel = "Deshacer",
                        withDismissAction = true,
                        duration = SnackbarDuration.Indefinite
                    )
                    when (resultado) {
                        SnackbarResult.ActionPerformed -> { /* Recupera el correo */ }
                        SnackbarResult.Dismissed -> { /* Se fue sin pulsar el botón */ }
                    }
                }
            }
        ) {
            Text("Archivar")
        }
    }
}

Los parámetros de showSnackbar(), según la referencia de SnackbarHostState:

Parámetro Qué hace
message El texto del Snackbar
actionLabel El texto del botón de acción. Si no lo pones, no hay botón
withDismissAction Si es true, añade un botón para cerrarlo. La referencia lo recomienda con la duración Indefinite, por accesibilidad
duration SnackbarDuration.Short, Long o Indefinite

Si llamas a showSnackbar() mientras ya se ve otro, el nuevo espera su turno: SnackbarHostState garantiza que solo se muestre uno a la vez.

Un Toast en Compose

Compose no tiene un Toast propio: se usa el mismo Toast de Android. Lo único que cambia es de dónde sale el contexto, que en una función @Composable se obtiene con LocalContext.current:

import android.widget.Toast
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalContext

@Composable
fun BotonGuardar() {
    val context = LocalContext.current
    Button(onClick = {
        Toast.makeText(context, "Guardado", Toast.LENGTH_SHORT).show()
    }) {
        Text("Guardar")
    }
}

Snackbar con Views y Material Components

Si tu app usa layouts XML, el Snackbar es la clase com.google.android.material.snackbar.Snackbar.

1. Añade la dependencia

En el build.gradle.kts del módulo:

dependencies {
    implementation("com.google.android.material:material:1.14.0")
}

2. Muéstralo

A diferencia del Toast, el Snackbar necesita una vista a la que engancharse. Según la documentación, Snackbar.make() sube desde esa vista hasta encontrar un CoordinatorLayout o la vista de contenido de la ventana.

val layout = findViewById<ConstraintLayout>(R.id.constraint)

// Igual que el Toast, pero en vez de un contexto le pasas una vista
Snackbar.make(layout, "Hello from the SnackBar!", Snackbar.LENGTH_LONG).show()

Si envuelves tu layout en un CoordinatorLayout, el Snackbar gana dos cosas: se puede descartar deslizándolo y aparta los botones flotantes (FAB) en vez de taparlos:

<androidx.coordinatorlayout.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/myCoordinatorLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <!-- Tu layout de siempre va aquí dentro -->

</androidx.coordinatorlayout.widget.CoordinatorLayout>

Aquí no hay cola como en Compose: según la referencia de Material Components, si ya se está mostrando un Snackbar y lanzas otro, el anterior se cierra (con el evento DISMISS_EVENT_CONSECUTIVE, que indica que se cerró porque se muestra uno nuevo) y el nuevo aparece en su lugar.

3. Snackbar con botón de acción

Al pulsar el botón UNDO del primer Snackbar se ejecuta la acción, que en este ejemplo muestra un segundo Snackbar:

// setAction(texto del botón, lo que pasa al pulsarlo)
Snackbar.make(layout, "Hello from the SnackBar!", Snackbar.LENGTH_LONG)
    .setAction("UNDO") {
        Snackbar.make(layout, "Email has been restored", Snackbar.LENGTH_LONG).show()
    }
    .show()

Además de LENGTH_SHORT y LENGTH_LONG, existe Snackbar.LENGTH_INDEFINITE, que lo deja visible hasta que el usuario lo descarta o pulsa la acción.

Toast en Android

// Parámetros: (contexto, texto, duración)
Toast.makeText(this, "Hello from the Toast", Toast.LENGTH_LONG).show()
  • this es el contexto: dentro de una activity, la propia activity.
  • La duración es Toast.LENGTH_SHORT (la de por defecto) o Toast.LENGTH_LONG.
  • Si tu app apunta a Android 12 (API 31) o superior, el Toast se limita a dos líneas y muestra el icono de la app al lado. Escribe mensajes cortos.
  • Desde Android 11 (API 30), setView() está obsoleto y, en apps que apuntan a esa versión, setGravity() y setMargin() no hacen nada en los Toast de texto. Si necesitas un mensaje con otro aspecto o en otro sitio, usa un Snackbar.

Un uso típico del Toast es el aviso de pulsar dos veces atrás para salir.

Cuándo usar un Snackbar, según Material Design 3

Las guías de Material Design 3 dan unas reglas claras. Este es nuestro resumen:

  • Para mensajes que no interrumpen. Confirmar una acción («Correo archivado», con «Deshacer»), avisar de que la app se ha quedado sin conexión o de que un cambio se ha guardado. Si el usuario tiene que decidir algo antes de seguir, lo que toca es un diálogo.
  • Una sola acción, como mucho. El botón de cerrar es opcional, porque el Snackbar se va solo.
  • Uno a la vez. No se apilan: el siguiente espera, o sustituye al anterior si trae información más reciente.
  • Duración. Sin acción, se cierra solo tras unos 4 a 10 segundos, según la plataforma. Con acción, debería quedarse hasta que el usuario actúe o lo cierre.
  • Abajo y sin tapar nada importante. Ni la navegación ni el botón flotante: si hay un FAB, el Snackbar va encima de él, no delante ni detrás.
  • Sin iconos ni enlaces. Si el mensaje necesita un icono, usa otro componente, como un diálogo; si necesita un enlace, pon un botón.
  • Nunca como única vía. La acción del Snackbar no debe ser la única forma de hacer algo importante, porque puede desaparecer antes de que el usuario la vea. La documentación de Android lo repite: ofrece otra manera de hacer esa acción.

Errores típicos

  • Llamar a showSnackbar() fuera de una corrutina. Es una función suspend y no compila si la llamas directamente desde el onClick. Envuélvela en scope.launch { }.
  • Crear SnackbarHostState sin remember. Se crearía uno nuevo en cada recomposición y se perdería la cola de mensajes.
  • Olvidar el snackbarHost del Scaffold. showSnackbar() no tiene dónde dibujar el mensaje y no se ve nada. Además, como la función espera a que el Snackbar desaparezca, esa llamada se queda suspendida y los siguientes Snackbar esperan detrás (deducción nuestra a partir de la referencia).
  • Un Snackbar Indefinite sin forma de cerrarlo. Si no lleva acción ni withDismissAction = true, se queda en pantalla.
  • En Views, esperar que se pueda deslizar sin CoordinatorLayout. Sin él, el Snackbar funciona, pero no se descarta deslizándolo y puede tapar el FAB.
  • Muchos Toast seguidos desde segundo plano. Android limita cuántos se pueden enviar desde segundo plano, así que algunos no aparecerán.

Si quieres lanzar el Snackbar al pulsar un botón en Views, mira eventos y clicks en Android. Y si estás empezando, el punto de partida es el hola mundo con Android Studio y Kotlin.

Fuentes

Consultadas el 9 de noviembre de 2026: