Escribir sus propios widgets es el centro del trabajo con [Flutter]: una pantalla bien escrita se compone de pequeños widgets, cada uno con sus propios parámetros, su [build] y, si es necesario, su estado. Este capítulo muestra cómo se comunican entre sí (parámetros, funciones), cómo se ensamblan (composición), cómo funcionan (ciclo de vida), cómo comparten datos sin pasarlos de uno a otro (datos heredados) y cómo reutilizar comportamientos.
4.1.1. Tipo de datos
El padre y el hijo comparten una clase, definida en su propio archivo:
| // el tipo de dato compartido por el padre (DoctorsPage) y el hijo (DoctorCard)
class Doctor {
final int id;
final String title;
final String firstName;
final String lastName;
final String specialty;
final bool available;
const Doctor({
required this.id,
required this.title,
required this.firstName,
required this.lastName,
required this.specialty,
required this.available,
});
// una copia en la que solo cambia la disponibilidad
Doctor withAvailability(bool d) =>
Doctor(id: id, title: title, firstName: firstName, lastName: lastName, specialty: specialty, available: d);
}
|
- líneas 10–16: un constructor con parámetros con nombre, todos obligatorios: [Doctor(id: 1, title: 'Mme', ...)]. Los parámetros con nombre hacen legible la llamada, y su orden no importa;
- líneas 20–21: una copia en la que solo cambia la disponibilidad (el objeto en sí nunca cambia).
4.1.2. El hijo
| // =========================================================================
// lib/ex10_widget_parameters/doctor_card.dart - un widget HIJO
// -------------------------------------------------------------------------
// Recibe sus datos de su padre mediante los PARÁMETROS de su
// constructor, guardados en campos final. Su tipo se verifica en
// tiempo de compilación: DoctorCard(doctor: 42) sería rechazado.
// - required: el padre DEBE proporcionar este parámetro;
// - this.compact = false: un parámetro opcional, con su valor por defecto.
//
// Regla de oro: un widget NUNCA MODIFICA sus parámetros (son final).
// Los datos bajan del padre al hijo; para solicitar un
// cambio, el hijo llama a una función que el padre le pasó
// (ver ejemplo 11). Cuando el padre cambia sus datos, RECONSTRUYE
// a sus hijos con nuevos parámetros.
// =========================================================================
import 'package:flutter/material.dart';
import 'doctor.dart';
// el "estilo" de la tarjeta: constantes PRIVADAS de este archivo (el "_").
// Ningún otro widget puede verlas ni verse afectado por ellas
const _initialsColor = Color(0xFF087EA4);
const _initialsStyle = TextStyle(color: Colors.white, fontWeight: FontWeight.bold);
class DoctorCard extends StatelessWidget {
final Doctor doctor;
final int rank;
final bool compact;
// const: si todos los parámetros son constantes, el widget también lo es
// (Flutter ni siquiera necesita reconstruirlo)
const DoctorCard({super.key, required this.doctor, required this.rank, this.compact = false});
@override
Widget build(BuildContext context) {
// un valor calculado a partir de los parámetros
final initials = '${doctor.firstName[0]}${doctor.lastName[0]}';
return Card(
// un borde verde para un médico disponible
shape: RoundedRectangleBorder(
borderRadius: BorderRadius.circular(12),
side: doctor.available ? const BorderSide(color: Colors.green, width: 2) : BorderSide.none,
),
child: Padding(
padding: const EdgeInsets.all(12),
child: Row(
children: [
CircleAvatar(
backgroundColor: _initialsColor,
child: Text(initials, style: _initialsStyle),
),
const SizedBox(width: 12),
// Expanded: el texto ocupa todo el ancho restante
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'$rank. ${doctor.title} ${doctor.firstName} ${doctor.lastName}',
style: Theme.of(context).textTheme.titleMedium,
),
if (!compact) Text(doctor.specialty, style: const TextStyle(color: Colors.grey)),
],
),
),
],
),
),
);
}
}
|
- líneas 23–24: el “estilo” de la tarjeta: constantes privadas de este archivo (el “_”). Ningún otro archivo puede verlas ni verse afectado por ellas. Es el equivalente, en [Flutter], de los “módulos CSS” de [React]: no hay una hoja de estilos global; el estilo de un widget está incorporado en su código;
- líneas 27–29: los parámetros del widget, almacenados en campos [final];
- línea 33: el constructor. [required this.doctor]: un parámetro obligatorio, almacenado directamente en el campo; [this.compact = false]: un parámetro opcional, con su valor predeterminado. El constructor es [const]: si todos los argumentos son constantes, la tarjeta también es constante;
- línea 38: un valor calculado a partir de los parámetros;
- líneas 42–44: la forma de la tarjeta ([Card]): esquinas redondeadas y un borde verde si el médico está disponible ([BorderSide.none] en caso contrario);
- líneas 50–52: un disco de color con las iniciales;
- línea 64: la especialidad solo se muestra en la vista no compacta.
Regla de oro: un widget nunca modifica sus propios parámetros (son [final]; por cierto, el compilador lo prohíbe). Los datos fluyen del padre al hijo; para solicitar un cambio, el hijo llama a una función que le pasó el padre (ejemplo 11). Cuando el padre cambia sus datos, reconstruye a sus hijos con nuevos parámetros.
4.1.3. El padre
| // =========================================================================
// lib/ex10_widget_parameters/main.dart - el widget PADRE
// -------------------------------------------------------------------------
// Importa el widget DoctorCard y lo usa, tantas veces como
// haga falta, como cualquier widget de Flutter: un widget es una pieza
// de interfaz REUTILIZABLE, con sus propios parámetros, su build() y
// su estilo. Escribir sus propios widgets es el corazón del trabajo con
// Flutter: una pantalla bien escrita se compone de pequeños widgets.
// =========================================================================
import 'package:flutter/material.dart';
import 'doctor_card.dart';
import 'doctor.dart';
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const DoctorsPage(),
),
);
}
class DoctorsPage extends StatefulWidget {
const DoctorsPage({super.key});
@override
State<DoctorsPage> createState() => _DoctorsPageState();
}
class _DoctorsPageState extends State<DoctorsPage> {
List<Doctor> _doctors = const [
Doctor(id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner', available: true),
Doctor(id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician', available: false),
Doctor(id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner', available: true),
];
bool _compact = false;
// el padre cambia SUS datos: Flutter vuelve a llamar a su build(), que
// reconstruye a los hijos con sus nuevos parámetros
void _toggleAvailability() {
setState(() {
_doctors = [for (final m in _doctors) m.withAvailability(!m.available)];
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Example 10 - the widgets and their parameters')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
SwitchListTile(
contentPadding: EdgeInsets.zero,
title: const Text('compact display'),
value: _compact,
onChanged: (v) => setState(() => _compact = v),
),
Align(
alignment: Alignment.centerLeft,
child: OutlinedButton(onPressed: _toggleAvailability, child: const Text('Toggle the availabilities')),
),
const SizedBox(height: 8),
for (final (i, m) in _doctors.indexed)
// cada tarjeta recibe SUS parámetros
DoctorCard(key: ValueKey(m.id), doctor: m, rank: i + 1, compact: _compact),
const SizedBox(height: 16),
const Text(
'The same card, in its compact version, by setting the parameter:',
style: TextStyle(color: Colors.grey),
),
SizedBox(width: 260, child: DoctorCard(doctor: _doctors[0], rank: 1, compact: true)),
],
),
);
}
}
|
- líneas 34–39: el estado del padre: la lista de médicos (una lista constante, que será reemplazada por otra) y la visualización compacta;
- líneas 43–45: el padre cambia SUS datos por una nueva lista formada por copias de los médicos. [Flutter] llama a su [build], que reconstruye las tarjetas con sus nuevos parámetros;
- línea 69: una tarjeta por médico, con SUS parámetros. El widget [DoctorCard] se utiliza exactamente como un widget de [Flutter];
- línea 75: la misma tarjeta, en versión compacta, en un recuadro de 260 puntos de ancho.
Al inicio, y luego en la vista compacta, la disponibilidad se invierte:
¿Un método que crea widgets (como [_line] del ejemplo 02) o un widget real ([DoctorCard])? Casi siempre es preferible el widget real: tiene un nombre, sus parámetros están tipados y documentados, puede reutilizarse en otro lugar, y [Flutter] puede evitar reconstruirlo (si es [const], o si sus parámetros no han cambiado).
4.2. Ejemplo 11: el hijo notifica a su padre
Los datos fluyen hacia abajo mediante parámetros; la información sube mediante funciones pasadas como parámetros.
4.2.1. "Eventos" del hijo
| // =========================================================================
// lib/ex11_lifting_state_up/counter.dart
// -------------------------------------------------------------------------
// Un hijo que NOTIFICA a su padre: el padre le pasa FUNCIONES como
// parámetros (por convención, su nombre empieza con "on"), y el hijo
// las llama cuando ocurre algo:
// Counter(label: 'Coffees', max: 3, onIncrement: ..., onLimit: ...)
// Los tipos de estas funciones tienen nombres predefinidos en Flutter:
// - ValueChanged<int> : una función que recibe un int y no devuelve nada;
// - VoidCallback : una función sin parámetros, que no devuelve nada.
// =========================================================================
import 'package:flutter/material.dart';
class Counter extends StatefulWidget {
final String label;
final int max;
final ValueChanged<int> onIncrement; // con el nuevo valor
final VoidCallback onLimit; // sin datos
const Counter({
super.key,
required this.label,
required this.max,
required this.onIncrement,
required this.onLimit,
});
@override
State<Counter> createState() => _CounterState();
}
class _CounterState extends State<Counter> {
// el estado PROPIO de este contador: cada Counter tiene el suyo
int _value = 0;
void _plus() {
// widget: en el objeto State, da acceso a los parámetros del widget
if (_value >= widget.max) {
widget.onLimit();
return;
}
setState(() => _value++);
// se NOTIFICA al padre, y recibe el nuevo valor
widget.onIncrement(_value);
}
@override
Widget build(BuildContext context) {
return Row(
children: [
SizedBox(width: 110, child: Text(widget.label)),
OutlinedButton(onPressed: _plus, child: const Text('+1')),
const SizedBox(width: 12),
Chip(label: Text('$_value / ${widget.max}')),
],
);
}
}
|
- líneas 18–19: dos parámetros que son funciones, a las que llamará el contador. [ValueChanged<int>] es el tipo de una función que recibe un [int] y no devuelve nada; [VoidCallback] es el tipo de una función sin parámetros. Por convención, sus nombres comienzan con “on”, como [onPressed] o [onChanged] en los widgets de [Flutter];
- línea 35: el estado PROPIO de este contador: cada [Counter] tiene el suyo;
- líneas 37–45: dentro del objeto [State], [widget] da acceso a los parámetros del widget: [widget.max], [widget.onLimit]... Si se excede el máximo, el contador notifica a su padre ([widget.onLimit()]); de lo contrario, cambia su estado y luego notifica a su padre transmitiéndole el nuevo valor. A diferencia de [React], el estado se actualiza de inmediato: [_value] ya tiene su nuevo valor cuando se transmite.
| // =========================================================================
// lib/ex11_lifting_state_up/labeled_text_field.dart - un widget CONTROLADO
// -------------------------------------------------------------------------
// Un campo de formulario "casero" (etiqueta + campo + ayuda + contador de
// caracteres) que se usa como un campo controlado:
// LabeledTextField(value: _name, onChanged: (v) => setState(() => _name = v), ...)
// El valor pertenece al PADRE, que lo pasa (value) y al que
// notifica cada pulsación de tecla (onChanged). El padre es quien decide.
//
// Una dificultad propia de Flutter: un TextField guarda su texto en un
// controlador, que debe sobrevivir a las reconstrucciones. Por tanto, el widget tiene
// un estado (el controlador)... que debe mantener ACTUALIZADO cuando el padre cambia
// el valor (botón "Clear"): ese es el papel de didUpdateWidget.
// =========================================================================
import 'package:flutter/material.dart';
class LabeledTextField extends StatefulWidget {
final String value;
final ValueChanged<String> onChanged;
final String label;
final int max;
final String help;
const LabeledTextField({
super.key,
required this.value,
required this.onChanged,
required this.label,
required this.max,
this.help = '',
});
@override
State<LabeledTextField> createState() => _LabeledTextFieldState();
}
class _LabeledTextFieldState extends State<LabeledTextField> {
// late: el campo se inicializará más tarde (en initState), antes de cualquier uso
late final TextEditingController _controller;
@override
void initState() {
super.initState();
_controller = TextEditingController(text: widget.value);
}
// se llama cuando el PADRE reconstruye este widget con nuevos parámetros;
// oldWidget: el widget anterior, para comparar
@override
void didUpdateWidget(LabeledTextField oldWidget) {
super.didUpdateWidget(oldWidget);
if (widget.value != _controller.text) {
_controller.text = widget.value; // el padre cambió el valor por sí mismo
}
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
final full = widget.value.length == widget.max;
return TextField(
controller: _controller,
maxLength: widget.max, // el campo rechaza los caracteres adicionales
decoration: InputDecoration(
labelText: widget.label,
helperText: widget.help,
// el borde se vuelve rojo cuando el campo está lleno
errorText: full ? 'Maximum length reached' : null,
),
onChanged: widget.onChanged, // la función del padre, pasada tal cual
);
}
}
|
Un campo de formulario “personalizado” (etiqueta + campo + información emergente + contador de caracteres) que funciona como un campo controlado: el valor pertenece al padre, que se lo pasa al campo ([value]) y es notificado de cada pulsación de tecla ([onChanged]).
- Línea 40: [late]: este campo se inicializará más tarde (en [initState]), pero antes de usarse. [Dart] lo verifica en tiempo de ejecución;
- Líneas 43–45: el controlador comienza con el valor del padre;
- líneas 51–54: este es el desafío específico de [Flutter]: un [TextField] almacena su texto en un controlador, que debe sobrevivir a las reconstrucciones de la página. Por lo tanto, el widget tiene un estado (el controlador)... que debe mantener al día cuando el padre cambia el valor por sí mismo (botón Borrar). [didUpdateWidget] se llama cada vez que el padre reconstruye este widget con nuevos parámetros; recibe el widget anterior para compararlo. Si el valor del padre difiere del texto del campo, se copia;
- línea 69: el campo rechaza los caracteres excedentes y muestra un contador (“12/20”);
- línea 72: una información emergente aparece debajo del campo;
- línea 74: el borde se vuelve rojo cuando el campo está lleno;
- línea 76: la función del padre, pasada tal cual a [TextField].
4.2.3. El padre
| // =========================================================================
// lib/ex11_lifting_state_up/main.dart - el padre escucha a sus hijos
// -------------------------------------------------------------------------
// Los datos bajan (parámetros); la información sube mediante
// funciones pasadas como parámetros:
// 1. los "eventos" del hijo: onIncrement, onLimit;
// 2. un widget controlado: value + onChanged, como un Checkbox. El estado
// sigue siendo propiedad del padre, que puede modificarlo él mismo (Clear).
// =========================================================================
import 'package:flutter/material.dart';
import 'labeled_text_field.dart';
import 'counter.dart';
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const ParentPage(),
),
);
}
class ParentPage extends StatefulWidget {
const ParentPage({super.key});
@override
State<ParentPage> createState() => _ParentPageState();
}
class _ParentPageState extends State<ParentPage> {
int _total = 0;
String _message = '';
String _firstName = 'Marie';
String _lastName = 'PELISSIER';
// la función a la que llama un contador: recibe el valor que el contador le pasa
void _onIncrement(String label, int value) {
setState(() {
_total++;
_message = '$label is now $value';
});
}
void _clear() {
setState(() {
_firstName = '';
_lastName = '';
});
}
@override
Widget build(BuildContext context) {
final titleStyle = Theme.of(context).textTheme.titleSmall;
return Scaffold(
appBar: AppBar(title: const Text('Example 11 - the child notifies its parent')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('1. Functions called by the children', style: titleStyle),
Counter(
label: 'Coffees',
max: 3,
onIncrement: (v) => _onIncrement('Coffees', v),
onLimit: () => setState(() => _message = 'No more than 3 coffees!'),
),
Counter(
label: 'Glasses of water',
max: 8,
onIncrement: (v) => _onIncrement('Glasses of water', v),
onLimit: () => setState(() => _message = 'Enough drinking.'),
),
const SizedBox(height: 8),
Text('Total of the clicks: $_total - $_message', style: const TextStyle(fontStyle: FontStyle.italic)),
],
),
),
),
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('2. Controlled widgets', style: titleStyle),
LabeledTextField(
value: _firstName,
onChanged: (v) => setState(() => _firstName = v),
label: 'First name',
max: 20,
help: 'Required',
),
LabeledTextField(
value: _lastName,
onChanged: (v) => setState(() => _lastName = v),
label: 'Last name',
max: 20,
help: 'Upper-cased when displayed',
),
const SizedBox(height: 8),
Text.rich(
TextSpan(
children: [
const TextSpan(text: "Parent's data: "),
TextSpan(
text: '$_firstName ${_lastName.toUpperCase()}',
style: const TextStyle(fontWeight: FontWeight.bold),
),
],
),
),
const SizedBox(height: 8),
OutlinedButton(onPressed: _clear, child: const Text('Clear (from the parent)')),
],
),
),
),
],
),
);
}
}
|
- líneas 40–43: la función a la que llama un contador; recibe el valor que le pasa el contador;
- líneas 69–73: un contador y las funciones a las que llamará. [(v) => _onIncrement('Coffees', v)]: una función anónima que agrega su propio argumento (la etiqueta);
- líneas 94–99: un campo controlado: su valor y la función que cambia el estado del padre;
- línea 114: los datos del padre, que siguen a lo ingresado;
- línea 121: el padre cambia el valor por sí mismo: se borran los campos (mediante su [didUpdateWidget]).
Presione cuatro veces el primer contador, una vez el segundo e ingrese el nombre; luego borre los campos desde el padre:
4.3. Ejemplo 12: composición
4.3.1. Una tarjeta
Los parámetros de un widget transmiten datos… pero también contenido: un widget es un valor como cualquier otro, que puede pasarse a otro widget. [Flutter] lo usa en todas partes: el [child] de un [Padding], el [title] de un [AppBar], el [body] de un [Scaffold].
| // =========================================================================
// lib/ex12_composition/info_card.dart - una PLANTILLA reutilizable
// -------------------------------------------------------------------------
// Los parámetros de un widget pasan DATOS... pero también
// CONTENIDO: un widget es un valor como cualquier otro, que se puede pasar a
// otro widget, que lo coloca donde quiera. Flutter usa esto en todas partes:
// el hijo de un Padding, el título de un AppBar, el cuerpo de un Scaffold...
// - child: por convención, el contenido "principal";
// - header, footer: otros lugares (algunos "slots"), proporcionados por el
// padre; el header tiene un contenido por defecto, el footer es opcional.
// La tarjeta define el marco (borde, header, footer), el padre proporciona lo que
// va dentro.
// =========================================================================
import 'package:flutter/material.dart';
class InfoCard extends StatelessWidget {
final Color? color; // "?": opcional (null por defecto)
final Widget header;
final Widget? footer;
final Widget child;
const InfoCard({super.key, this.color, this.header = const Text('Untitled'), this.footer, required this.child});
@override
Widget build(BuildContext context) {
final background = color ?? Colors.grey.shade300;
return Card(
// clipBehavior: el encabezado de color sigue las esquinas redondeadas de la tarjeta
clipBehavior: Clip.antiAlias,
shape: RoundedRectangleBorder(
borderRadius: BorderRadius.circular(8),
side: BorderSide(color: background),
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Container(
color: background,
padding: const EdgeInsets.all(10),
// DefaultTextStyle: el estilo de TODOS los textos del encabezado,
// sea cual sea el widget proporcionado por el padre
child: DefaultTextStyle.merge(
style: TextStyle(color: color == null ? Colors.black : Colors.white, fontWeight: FontWeight.bold),
child: header,
),
),
Padding(padding: const EdgeInsets.all(10), child: child),
// sin pie proporcionado: ningún pie en absoluto
if (footer != null)
Container(
color: Colors.grey.shade100,
padding: const EdgeInsets.all(8),
child: DefaultTextStyle.merge(
style: const TextStyle(color: Colors.grey, fontSize: 12),
child: footer!,
),
),
],
),
);
}
}
|
- líneas 18–21: parámetros: un color opcional ([Color?]) y tres ranuras para contenido: [header], [footer] (opcional), y [child], el contenido principal;
- línea 23: el encabezado tiene contenido predeterminado: un widget constante;
- línea 27: el color del encabezado: el proporcionado, o gris claro;
- línea 30: el encabezado de color se recorta para que coincida con las esquinas redondeadas de la tarjeta;
- líneas 43–45: [DefaultTextStyle] define el estilo de TODO el texto de su subárbol, sea cual sea el widget proporcionado por el padre: el encabezado está en negrita, en blanco sobre un fondo de color;
- línea 48: el contenido principal, proporcionado por el padre;
- líneas 50–58: sin pie de página proporcionado; no se muestra ninguno. [footer!]: en esta rama, [footer] no es [null] (el compilador no puede inferirlo para un campo, de ahí el [!]).
4.3.2. Una tabla genérica
| // =========================================================================
// lib/ex12_composition/simple_table.dart - una tabla GENÉRICA
// -------------------------------------------------------------------------
// SimpleTable<T> es un widget genérico: muestra filas de cualquier
// tipo T. Sabe recorrer las filas, pero no cómo mostrar UNA
// fila: el padre se lo indica, pasándole una FUNCIÓN,
// cells(row, index), que devuelve los widgets de las celdas.
// Es el principio de los "builders" de Flutter (ListView.builder,
// FutureBuilder...): el contenido proporcionado por el padre usa datos
// que pertenecen al hijo (la fila, su posición).
// =========================================================================
import 'package:flutter/material.dart';
// el tipo de una función que construye las celdas de una fila
typedef CellsBuilder<T> = List<Widget> Function(T row, int index);
class SimpleTable<T> extends StatelessWidget {
final List<T> rows;
final List<String> columns;
final CellsBuilder<T> cells;
final Widget empty; // se muestra cuando no hay ninguna fila
const SimpleTable({
super.key,
required this.rows,
required this.columns,
required this.cells,
this.empty = const Text('No data.'),
});
// una celda: un pequeño margen alrededor de su contenido
static Widget _cell(Widget content) => Padding(padding: const EdgeInsets.all(6), child: content);
@override
Widget build(BuildContext context) {
if (rows.isEmpty) {
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(columns.join(' '), style: const TextStyle(fontWeight: FontWeight.bold)),
const Divider(),
DefaultTextStyle.merge(
style: const TextStyle(color: Colors.grey),
child: empty,
),
],
);
}
return Table(
defaultVerticalAlignment: TableCellVerticalAlignment.middle,
border: TableBorder(horizontalInside: BorderSide(color: Colors.grey.shade300)),
children: [
TableRow(
children: [for (final c in columns) _cell(Text(c, style: const TextStyle(fontWeight: FontWeight.bold)))],
),
for (final (i, row) in rows.indexed)
// las celdas de ESTA fila, construidas por la función del padre
TableRow(children: [for (final c in cells(row, i)) _cell(c)]),
],
);
}
}
|
- línea 16: el tipo de una función que recibe una fila (de tipo [T]) y su índice, y devuelve los widgets de sus celdas;
- línea 18: un widget genérico: muestra filas de cualquier tipo ([T]). Sabe recorrer las filas, pero no cómo mostrar UNA fila; el padre se lo indica pasándole la función [cells]. Este es el principio de los “builders” de [Flutter] ([ListView.builder], [FutureBuilder]...): el contenido lo proporciona el padre, pero usa datos que pertenecen al hijo (la fila, su índice). [React] lo llama “render prop”;
- línea 33: un método [static], que no usa ningún campo del widget;
- líneas 37–45: sin filas: los encabezados de las columnas y el contenido [empty], proporcionado por el padre;
- líneas 50–59: la tabla: una fila de encabezados, seguida de una fila por elemento, cuyas celdas genera la función del padre.
4.3.3. El padre
| // =========================================================================
// lib/ex12_composition/main.dart - usar las plantillas InfoCard y SimpleTable
// =========================================================================
import 'package:flutter/material.dart';
import 'info_card.dart';
import 'simple_table.dart';
// un slot: un record con nombres (sin necesidad de escribir una clase)
typedef Slot = ({int id, String timeRange, String? patient});
const slots = <Slot>[
(id: 1, timeRange: '8:00 - 8:20', patient: null),
(id: 2, timeRange: '8:20 - 8:40', patient: 'Mme Alice DURAND'),
(id: 3, timeRange: '8:40 - 9:00', patient: null),
];
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const CompositionPage(),
),
);
}
class CompositionPage extends StatelessWidget {
const CompositionPage({super.key});
@override
Widget build(BuildContext context) {
final free = slots.where((c) => c.patient == null).length;
return Scaffold(
appBar: AppBar(title: const Text('Example 12 - the composition')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
// header y footer: widgets pasados como parámetros; child: el contenido
InfoCard(
color: Colors.indigo,
header: const Row(
children: [
Icon(Icons.event, color: Colors.white),
SizedBox(width: 8),
// Expanded: el texto ocupa el espacio restante (y salta de línea)
Expanded(child: Text('Schedule of Mme PELISSIER')),
],
),
footer: Text('$free free slot(s)'),
// SimpleTable<Slot>: T se infiere del tipo de las filas
child: SimpleTable(
rows: slots,
columns: const ['#', 'Slot', 'Status'],
// la función que construye las celdas de UNA fila;
// c recibe la fila, i su posición
cells: (c, i) => [
Text('${i + 1}'),
Text(c.timeRange),
c.patient != null
? Chip(label: Text(c.patient!), visualDensity: VisualDensity.compact)
: Chip(
label: const Text('Free'),
backgroundColor: Colors.green.shade100,
visualDensity: VisualDensity.compact,
),
],
),
),
const InfoCard(
color: Colors.green,
header: Text('A card without a footer'),
child: Text('The footer is not provided: the card does not display it.'),
),
// sin encabezado proporcionado: el contenido por defecto, "Untitled"
InfoCard(
child: SimpleTable<({int id, String name})>(
rows: const [],
columns: const ['Name'],
cells: (p, _) => [Text(p.name)],
empty: const Text('Nobody for now.'),
),
),
],
),
);
}
}
|
- línea 11: una ranura, en forma de record con nombre;
- líneas 42–52: una tarjeta: su color, un encabezado (una línea: un ícono y un texto), un pie de página;
- líneas 54–66: su contenido: una tabla de ranuras. [T] se deduce del tipo de [rows]: es un [SimpleTable<Slot>]. La función [cells] recibe un horario ([c]) y su posición ([i]), y devuelve tres widgets;
- líneas 72–75: una tarjeta sin pie de página;
- líneas 79–83: una tarjeta sin encabezado (el contenido predeterminado, “Untitled”); su tabla está vacía. [SimpleTable<({int id, String name})>]: el tipo [T] se especifica explícitamente, porque [rows: const []] no permite inferirlo.

La tarjeta define el marco (borde, encabezado, pie de página); el padre proporciona el contenido interior. Así se construyen los propios widgets de [Flutter]: [Scaffold] define la estructura de una pantalla y recibe la barra superior, el cuerpo y el botón flotante.
4.4.1. Un reloj
| // =========================================================================
// lib/ex13_lifecycle/clock.dart - un widget que se inicia y se detiene
// -------------------------------------------------------------------------
// La vida del objeto State de un StatefulWidget:
// 1. initState() : acaba de crearse, el widget está a punto de
// aparecer. Lo que debe iniciarse se inicia aquí;
// 2. didChangeDependencies() : justo después, y luego cada vez que cambia un
// dato heredado que lee (ver ejemplo 14);
// 3. build() : tantas veces como haga falta;
// 4. didUpdateWidget(old) : el padre lo reconstruyó con nuevos
// parámetros;
// 5. dispose() : el widget desaparece definitivamente. Lo que
// se inició se DETIENE aquí.
// Un reloj lanza un temporizador (Timer.periodic) cuando aparece...
// y debe detenerlo imperativamente cuando desaparece: de lo contrario, el
// temporizador seguiría ejecutándose inútilmente, y llamaría a setState()
// sobre un objeto muerto (un error).
// =========================================================================
import 'dart:async';
import 'package:flutter/material.dart';
String currentTime() => DateTime.now().toString().substring(11, 19); // "12:05:09"
class Clock extends StatefulWidget {
final ValueChanged<String> onLog;
final Color color;
const Clock({super.key, required this.onLog, this.color = Colors.indigo});
@override
State<Clock> createState() => _ClockState();
}
class _ClockState extends State<Clock> {
String _time = currentTime();
// late: se inicializa en initState
late final Timer _timer;
// notificar al padre... DESPUÉS de la construcción de la pantalla actual: no
// modificamos el estado de un widget (el padre) mientras se está construyendo
void _log(String message) {
WidgetsBinding.instance.addPostFrameCallback((_) => widget.onLog(message));
}
@override
void initState() {
super.initState(); // siempre primero
_log('Clock: initState - starting the timer');
_timer = Timer.periodic(const Duration(seconds: 1), (_) {
setState(() => _time = currentTime());
});
}
@override
void didUpdateWidget(Clock oldWidget) {
super.didUpdateWidget(oldWidget);
if (oldWidget.color != widget.color) {
_log('Clock: didUpdateWidget - new color');
}
}
@override
void dispose() {
_timer.cancel(); // la LIMPIEZA
_log('Clock: dispose - timer stopped');
super.dispose(); // siempre último
}
@override
Widget build(BuildContext context) {
return Text(
_time,
style: TextStyle(fontSize: 40, fontFamily: 'RobotoMono', color: widget.color),
);
}
}
|
El ciclo de vida del objeto [State] dentro de un [StatefulWidget]:
Método | ¿Cuándo? |
initState() | El objeto acaba de crearse; el widget va a aparecer. Aquí se inicia todo lo que deba iniciarse (temporizador, suscripción, etc.) |
didChangeDependencies() | Inmediatamente después de initState, y luego cada vez que cambia algún dato heredado que lee (véase el ejemplo 14) |
build() | tantas veces como sea necesario |
didUpdateWidget(old) | el padre lo ha reconstruido con nuevos parámetros |
dispose() | el widget desaparece definitivamente. Todo lo que se inició allí se detiene |
- líneas 37–39: el estado: la hora mostrada y un temporizador ([Timer], de la biblioteca [dart:async]);
- líneas 43–44: el reloj notifica a su padre cada etapa de su ciclo de vida. Pero lo hace durante [initState] o [dispose], es decir, mientras [Flutter] construye la pantalla: el padre no puede modificar su estado en ese momento ([setState] provocaría un error). [addPostFrameCallback] difiere la llamada hasta después de que termine de dibujarse el cuadro actual;
- líneas 48–52: [super.initState()] primero, siempre. Luego se inicia un temporizador periódico: su función se llama cada segundo y actualiza la hora;
- líneas 57–60: el padre ha redibujado el reloj con un color diferente: se toma nota de ello;
- líneas 65–68: limpieza: se detiene el temporizador. De lo contrario, seguiría ejecutándose inútilmente y llamaría a [setState] sobre un objeto muerto, lo que produciría un error (“setState() called after dispose()”) y una fuga de memoria. [super.dispose()] va siempre al final.
4.4.2. El padre
| // =========================================================================
// lib/ex13_lifecycle/main.dart
// -------------------------------------------------------------------------
// - if (_withClock) Clock(...): marcar / desmarcar la casilla hace
// que el widget aparezca / desaparezca (initState, luego dispose, ver
// clock.dart); cambiar su color lo reconstruye (didUpdateWidget);
// - autofocus: un campo de entrada que toma el foco en cuanto aparece
// (se abre el teclado del teléfono);
// - el título de la aplicación sigue a la entrada (widget Title);
// - AppLifecycleListener: la vida de la APLICACIÓN misma. En un
// teléfono, pasa a segundo plano (se abre otra aplicación,
// se apaga la pantalla), y luego vuelve: podemos reaccionar a ello (guardar,
// detener un temporizador...).
// =========================================================================
import 'package:flutter/material.dart';
import 'clock.dart';
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const LifecyclePage(),
),
);
}
class LifecyclePage extends StatefulWidget {
const LifecyclePage({super.key});
@override
State<LifecyclePage> createState() => _LifecyclePageState();
}
class _LifecyclePageState extends State<LifecyclePage> {
bool _withClock = true;
bool _red = false;
final List<String> _log = [];
String _search = '';
bool _showSearch = false;
late final AppLifecycleListener _listener;
void _trace(String message) {
// el reloj puede notificar DESPUÉS de que la pantalla haya desaparecido (cierre de la aplicación)
if (!mounted) return;
setState(() => _log.add('${currentTime()} $message'));
}
@override
void initState() {
super.initState();
// la aplicación cambia de estado: resumed (en primer plano), inactive,
// hidden, paused (en segundo plano)...
_listener = AppLifecycleListener(onStateChange: (state) => _trace('Application: ${state.name}'));
}
@override
void dispose() {
_listener.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return Title(
title: _search.isEmpty ? 'Example 13' : 'Search: $_search',
color: Colors.indigo,
child: Scaffold(
appBar: AppBar(title: const Text('Example 13 - the lifecycle')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
CheckboxListTile(
contentPadding: EdgeInsets.zero,
controlAffinity: ListTileControlAffinity.leading,
title: const Text('show the clock'),
value: _withClock,
onChanged: (v) => setState(() => _withClock = v!),
),
CheckboxListTile(
contentPadding: EdgeInsets.zero,
controlAffinity: ListTileControlAffinity.leading,
title: const Text('in red'),
value: _red,
onChanged: (v) => setState(() => _red = v!),
),
if (_withClock) Clock(onLog: _trace, color: _red ? Colors.red : Colors.indigo),
],
),
),
),
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: !_showSearch
? Align(
alignment: Alignment.centerLeft,
child: OutlinedButton(
onPressed: () => setState(() => _showSearch = true),
child: const Text('Search...'),
),
)
// autofocus: el foco en cuanto aparece el campo
: TextField(
autofocus: true,
decoration: const InputDecoration(hintText: 'the title follows the input'),
onChanged: (v) => setState(() => _search = v),
),
),
),
Text('Log', style: Theme.of(context).textTheme.titleSmall),
for (final (i, line) in _log.indexed) Text('${i + 1}. $line', style: const TextStyle(fontSize: 12)),
],
),
),
);
}
}
|
- líneas 56–61: la vida de la aplicación misma. En un teléfono, pasa a segundo plano (se abre otra aplicación, se apaga la pantalla) y luego regresa: [AppLifecycleListener] notifica cada cambio ([resumed]: en primer plano; [inactive], [hidden], [paused]: paso a segundo plano...). Se respondería a estas notificaciones para guardar un borrador o detener un temporizador. El listener se crea en [initState] y se libera en [dispose]: el mismo patrón que el temporizador del reloj;
- línea 95: al marcar la casilla se muestra el reloj ([initState]); al desmarcarla se oculta ([dispose]); al cambiar su color se redibuja ([didUpdateWidget]);
- líneas 112–115: un campo que aparece solo después de tocar “Search...”. [autofocus: true]: obtiene el foco en cuanto aparece y se abre el teclado del teléfono;
- línea 68: el título de la aplicación se actualiza mientras se escribe.
Cambiamos el color, quitamos y volvemos a agregar el reloj, abrimos la búsqueda y escribimos un nombre:

El registro muestra la actividad del reloj: inicio, cambio de color, detención, inicio.
Los estudiantes que cursen el curso de [React] lo compararán con [useEffect]: lo que [React] escribe en un efecto y su función de limpieza, [Flutter] lo distribuye entre [initState] y [dispose]; lo que [React] obtiene de la tabla de dependencias de un efecto, [Flutter] lo obtiene mediante [didUpdateWidget], comparando el widget anterior con el nuevo.
4.5. Ejemplo 14: datos heredados
¿Cómo compartir datos y funciones entre widgets distantes sin pasarlos de parámetro en parámetro a través de todos los intermediarios? Con datos heredados, como [InheritedWidget]. Este es el mecanismo que utiliza [Flutter] mismo: [Theme.of(context)], [MediaQuery.of(context)], [Navigator.of(context)]... son lecturas de datos heredados. [React] lo llama contexto; [Angular] lo llamaría servicio.
4.5.1. Un conjunto de datos para toda la aplicación
| // =========================================================================
// lib/ex14_inherited_data/providers/log.dart - un dato para TODA la aplicación
// -------------------------------------------------------------------------
// ¿Cómo compartir datos y funciones entre widgets distantes,
// sin pasarlos de parámetro en parámetro a través de todos los
// intermediarios? Con un InheritedWidget, un dato "heredado":
// 1. un widget PROVEEDOR, colocado en lo alto del árbol, lleva los datos;
// 2. cualquier descendiente, a cualquier profundidad, los LEE
// con context.dependOnInheritedWidgetOfExactType<Provider>();
// 3. el descendiente que los ha leído queda entonces SUSCRITO: se reconstruye
// cuando los datos cambian.
// Es el mecanismo que usa el propio Flutter: Theme.of(context),
// MediaQuery.of(context), Navigator.of(context)... son lecturas de
// datos heredados.
//
// InheritedNotifier es una variante lista para usar: el dato es un objeto
// que NOTIFICA sus cambios (un ChangeNotifier, que llama a
// notifyListeners()), y el proveedor reconstruye entonces a sus lectores.
// La convención: un método estático of(context) para leer el dato.
// =========================================================================
import 'package:flutter/material.dart';
// el dato: un ChangeNotifier. notifyListeners() notifica a sus suscriptores
class Log extends ChangeNotifier {
final List<String> lines = [];
void trace(String message) {
lines.insert(0, '${DateTime.now().toString().substring(11, 19)} $message');
if (lines.length > 6) lines.removeLast();
notifyListeners();
}
}
// el proveedor: lleva el registro (log), y reconstruye a sus lectores cuando
// el registro notifica un cambio
class LogProvider extends InheritedNotifier<Log> {
const LogProvider({super.key, required Log log, required super.child}) : super(notifier: log);
// la lectura: el proveedor MÁS CERCANO por encima de context
static Log of(BuildContext context) {
final provider = context.dependOnInheritedWidgetOfExactType<LogProvider>();
if (provider == null) {
throw FlutterError('LogProvider.of: no LogProvider above this widget');
}
return provider.notifier!;
}
}
|
- líneas 25–31: los datos compartidos: un registro. Es un [ChangeNotifier], un objeto que notifica a sus oyentes los cambios: todo método que lo modifica llama a [notifyListeners()];
- líneas 37–38: el proveedor: un widget, ubicado en lo alto del árbol, que contiene el registro. [InheritedNotifier] es un [InheritedWidget] listo para un [ChangeNotifier]: cuando el registro notifica un cambio, el proveedor reconstruye todos los widgets que lo han leído;
- líneas 41–46: la lectura, mediante un método estático [of(context)], tal como lo usa [Flutter]. [context.dependOnInheritedWidgetOfExactType<LogProvider>()] recorre el árbol desde [context] hacia arriba hasta el proveedor más cercano y suscribe al widget que lee los datos: se reconstruirá cuando los datos cambien. Si no hay un proveedor por encima, se trata de un error de programación: se señala claramente.
| // =========================================================================
// lib/ex14_inherited_data/providers/cart.dart - un dato proporcionado por UN widget
// -------------------------------------------------------------------------
// El carrito solo se proporciona a una parte del árbol: los widgets
// que CartProvider envuelve (ver main.dart). Dos proveedores colocados en
// dos lugares de la pantalla darían dos carritos independientes.
// Aquí el proveedor es un StatefulWidget: es quien CREA el carrito
// (didChangeDependencies) y lo libera (dispose). Usa el registro (log) por sí mismo.
// =========================================================================
import 'package:flutter/material.dart';
import 'log.dart';
typedef Item = ({String label, double price});
class Cart extends ChangeNotifier {
final Log _log;
final List<Item> items = [];
Cart(this._log);
// un valor calculado: fold "pliega" la lista en un solo valor
double get total => items.fold(0, (sum, a) => sum + a.price);
void add(Item item) {
items.add(item);
_log.trace('cart: + ${item.label}');
notifyListeners();
}
void remove(int index) {
_log.trace('cart: - ${items[index].label}');
items.removeAt(index);
notifyListeners();
}
}
class CartProvider extends StatefulWidget {
final Widget child;
const CartProvider({super.key, required this.child});
// la lectura, mediante el widget privado _InheritedCart colocado en build()
static Cart of(BuildContext context) {
final inherited = context.dependOnInheritedWidgetOfExactType<_InheritedCart>();
if (inherited == null) {
throw FlutterError('CartProvider.of: no CartProvider above this widget');
}
return inherited.notifier!;
}
@override
State<CartProvider> createState() => _CartProviderState();
}
class _CartProviderState extends State<CartProvider> {
Cart? _cart; // null mientras no se haya creado
// se llama justo después de initState: el widget puede entonces LEER los
// datos heredados. getInheritedWidgetOfExactType: leer el registro SIN suscribirse
// a sus cambios (el proveedor del carrito no tiene que reconstruirse
// cada vez que cambia el registro)
@override
void didChangeDependencies() {
super.didChangeDependencies();
// ??=: el carrito solo se crea la primera vez
_cart ??= Cart(context.getInheritedWidgetOfExactType<LogProvider>()!.notifier!);
}
@override
void dispose() {
_cart?.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) => _InheritedCart(notifier: _cart!, child: widget.child);
}
class _InheritedCart extends InheritedNotifier<Cart> {
const _InheritedCart({required super.notifier, required super.child});
}
|
- líneas 17–24: el carrito de compras, otro [ChangeNotifier]. Recibe el registro al crearse para anotar cada adición y cada eliminación. [fold] “colapsa” la lista en un solo valor: la suma de los precios;
- líneas 39–40: esta vez, el proveedor es un [StatefulWidget]: es quien crea el carrito de compras y lo libera. Solo se proporciona a los widgets que abarca ([child]);
- líneas 45–50: el widget privado [_InheritedCart], que el proveedor coloca por encima de su hijo, lee los datos;
- líneas 65–68: el carrito se crea en [didChangeDependencies], que se llama inmediatamente después de [initState], y desde el cual un widget puede leer los datos heredados. [??=]: se crea solo la primera vez. [getInheritedWidgetOfExactType] lee el registro SIN suscribirse a sus cambios: el proveedor del carrito no necesita reconstruirse cada vez que cambia el registro;
- línea 78: el proveedor coloca los datos heredados por encima de su hijo;
- líneas 81–82: los datos heredados propiamente dichos, que son privados.
4.5.3. Un proveedor configurado
| // =========================================================================
// lib/ex14_inherited_data/providers/clock.dart - un proveedor PARAMETRIZADO
// -------------------------------------------------------------------------
// Un reloj, cuyo período de actualización es un parámetro del
// proveedor: ClockProvider(period: Duration(seconds: 5), ...).
// Dos proveedores anidados: un widget lee el que está MÁS CERCA
// de él. Esta vez, escribimos un InheritedWidget "a mano":
// updateShouldNotify indica si los lectores deben reconstruirse.
// El reloj se detiene cuando su proveedor desaparece (dispose).
// =========================================================================
import 'dart:async';
import 'package:flutter/material.dart';
class ClockProvider extends StatefulWidget {
final Duration period;
final Widget child;
const ClockProvider({super.key, this.period = const Duration(seconds: 1), required this.child});
// el valor por defecto: una fecha congelada, leída por un widget sin proveedor
static DateTime of(BuildContext context) =>
context.dependOnInheritedWidgetOfExactType<_InheritedClock>()?.now ?? DateTime(2026);
@override
State<ClockProvider> createState() => _ClockProviderState();
}
class _ClockProviderState extends State<ClockProvider> {
DateTime _now = DateTime.now();
Timer? _timer;
void _start() {
_timer?.cancel();
_timer = Timer.periodic(widget.period, (_) => setState(() => _now = DateTime.now()));
}
@override
void initState() {
super.initState();
_start();
}
// si el padre cambia el período, el temporizador se reinicia
@override
void didUpdateWidget(ClockProvider oldWidget) {
super.didUpdateWidget(oldWidget);
if (oldWidget.period != widget.period) _start();
}
@override
void dispose() {
_timer?.cancel();
super.dispose();
}
@override
Widget build(BuildContext context) => _InheritedClock(now: _now, child: widget.child);
}
class _InheritedClock extends InheritedWidget {
final DateTime now;
const _InheritedClock({required this.now, required super.child});
// se llama cuando el proveedor se reconstruye: ¿deben reconstruirse los
// lectores? Sí, si la hora ha cambiado
@override
bool updateShouldNotify(_InheritedClock oldWidget) => oldWidget.now != now;
}
|
- línea 23: la operación de lectura; sin proveedor, un valor predeterminado (una fecha fija). [?.]: si no se encuentra ningún proveedor, el resultado es [null], y [??] toma entonces el valor predeterminado;
- líneas 34–36: un temporizador, con el período especificado como parámetro;
- líneas 47–49: si el padre cambia el período, el temporizador se reinicia;
- líneas 62–70: esta vez, un [InheritedWidget] escrito “a mano”. Transporta un dato (la hora). Cada vez que se reconstruye el proveedor (cada segundo), [Flutter] llama a [updateShouldNotify] con el widget anterior: si devuelve [true], se reconstruyen los widgets que leen los datos.
| // lib/ex14_inherited_data/catalog.dart - un descendiente que AGREGA al carrito
import 'package:flutter/material.dart';
import 'providers/cart.dart';
const catalog = <Item>[
(label: 'Consultation', price: 30),
(label: 'Vaccine', price: 12.5),
(label: 'Certificate', price: 5),
];
class Catalog extends StatelessWidget {
const Catalog({super.key});
@override
Widget build(BuildContext context) {
// el carrito proporcionado por ShopPage (un error si nadie lo proporciona)
final cart = CartProvider.of(context);
return Card(
child: Column(
children: [
for (final a in catalog)
ListTile(
dense: true,
title: Text('${a.label} (${a.price} €)'),
trailing: IconButton(icon: const Icon(Icons.add_shopping_cart), onPressed: () => cart.add(a)),
),
],
),
);
}
}
|
- Línea 18: el catálogo lee el carrito de compras proporcionado por encima y le agrega artículos.
| // =========================================================================
// lib/ex14_inherited_data/cart_summary.dart
// -------------------------------------------------------------------------
// Otro descendiente: el MISMO carrito que Catalog, pero SU PROPIO
// reloj, actualizado cada 5 segundos. Un widget solo lee los
// proveedores colocados POR ENCIMA de él: CartSummary coloca por tanto un segundo
// ClockProvider alrededor de su contenido, que entrega a un pequeño
// widget, _Content (cuyo contexto está, él sí, POR DEBAJO de este proveedor).
// =========================================================================
import 'package:flutter/material.dart';
import 'providers/clock.dart';
import 'providers/cart.dart';
class CartSummary extends StatelessWidget {
const CartSummary({super.key});
@override
Widget build(BuildContext context) {
return const ClockProvider(period: Duration(seconds: 5), child: _Content());
}
}
class _Content extends StatelessWidget {
const _Content();
@override
Widget build(BuildContext context) {
final cart = CartProvider.of(context);
final now = ClockProvider.of(context); // el más cercano: el de 5 s
return Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'Cart (${cart.items.length} item(s)) - ${now.toString().substring(11, 19)}',
style: Theme.of(context).textTheme.titleSmall,
),
for (final (i, a) in cart.items.indexed)
Row(
children: [
Text(a.label),
TextButton(onPressed: () => cart.remove(i), child: const Text('remove')),
],
),
Text('Total: ${cart.total} €', style: const TextStyle(fontWeight: FontWeight.bold)),
],
),
),
);
}
}
|
- Línea 21: el resumen coloca un segundo proveedor de reloj, con un período de 5 segundos, alrededor de su contenido. Un widget solo lee los proveedores ubicados por encima de él: por eso el contenido es un widget separado, [_Content], cuyo [context] está DEBAJO de este proveedor (en cambio, el [context] de [CartSummary] está por encima);
- Líneas 30–31: lee el MISMO carrito que el catálogo, pero el reloj más cercano es el de 5 segundos.
| // =========================================================================
// lib/ex14_inherited_data/main.dart - tres niveles de datos heredados
// -------------------------------------------------------------------------
// - el registro (log): proporcionado en lo más alto (por encima de MaterialApp), a toda la
// aplicación;
// - el carrito, proporcionado por ShopPage: compartido por Catalog y
// CartSummary, que ven el MISMO carrito;
// - el reloj, proporcionado por ShopPage (período por defecto, 1 s) Y por
// CartSummary (5 s): cada uno el suyo.
// =========================================================================
import 'package:flutter/material.dart';
import 'catalog.dart';
import 'providers/clock.dart';
import 'providers/log.dart';
import 'providers/cart.dart';
import 'cart_summary.dart';
void main() {
runApp(
LogProvider(
log: Log(),
child: MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const ShopPage(),
),
),
);
}
// la hora del reloj de la página: un pequeño widget, colocado POR DEBAJO del proveedor
class _PageTime extends StatelessWidget {
const _PageTime();
@override
Widget build(BuildContext context) {
final time = ClockProvider.of(context).toString().substring(11, 19);
return Text('Clock of the page: $time', style: const TextStyle(color: Colors.grey));
}
}
class ShopPage extends StatelessWidget {
const ShopPage({super.key});
@override
Widget build(BuildContext context) {
// la página lee el registro (log): se reconstruirá con cada nueva línea
final log = LogProvider.of(context);
return ClockProvider(
child: CartProvider(
child: Scaffold(
appBar: AppBar(title: const Text('Example 14 - the inherited data')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
const _PageTime(),
const Catalog(),
const CartSummary(),
const SizedBox(height: 12),
Text('Log (provided to the whole application)', style: Theme.of(context).textTheme.titleSmall),
for (final line in log.lines) Text(line, style: const TextStyle(fontSize: 12)),
],
),
),
),
);
}
}
|
- líneas 22–24: el proveedor del registro se coloca por encima de [MaterialApp]: el registro está disponible en TODA la aplicación, incluidas las ventanas y otras pantallas;
- líneas 34–40: un pequeño widget, ubicado debajo del proveedor del reloj de la página;
- línea 50: la página lee el registro; se reconstruirá con cada nueva línea;
- líneas 51–52: la página proporciona un reloj (período predeterminado: un segundo) y un carrito de compras para todo lo que contiene.
Agregamos tres artículos y luego quitamos uno:

El reloj de la página avanza cada segundo; el reloj del carrito avanza cada cinco segundos. El registro muestra las adiciones y la eliminación. El ejemplo 20 delegará todo este trabajo al paquete [provider], que lo escribe en una sola línea, pero se basa exactamente en este mecanismo.
4.6. Ejemplo 15: reutilización de comportamientos
Un widget reutiliza una vista. ¿Cómo se reutiliza un comportamiento, junto con su estado (resaltar lo que se toca, desencadenar una acción tras una pulsación larga, dar el foco al iniciar)? [React] tiene “hooks personalizados”; [Flutter] y [Dart] tienen tres herramientas.
| // =========================================================================
// lib/ex15_behaviors/highlighter.dart - un comportamiento en un widget
// -------------------------------------------------------------------------
// La primera forma de reutilizar un COMPORTAMIENTO (con su estado): un
// widget "envoltorio", que agrega este comportamiento a cualquier hijo.
// Highlighter(color: ..., child: ListTile(...))
// Este resalta a su hijo mientras se le TOCA (el dedo puesto sobre
// la pantalla) y, con un mouse (web, computadora), mientras el cursor pasa SOBRE él.
// Cada Highlighter tiene su propio estado: dos filas no se afectan entre sí.
// =========================================================================
import 'package:flutter/material.dart';
class Highlighter extends StatefulWidget {
final Color color;
final Widget child;
const Highlighter({super.key, this.color = const Color(0xFFFFF3CD), required this.child});
@override
State<Highlighter> createState() => _HighlighterState();
}
class _HighlighterState extends State<Highlighter> {
bool _touched = false;
bool _hovered = false;
@override
Widget build(BuildContext context) {
// MouseRegion: los movimientos del mouse; Listener: los contactos
// del dedo (o los clics), al nivel más bajo
return MouseRegion(
onEnter: (_) => setState(() => _hovered = true),
onExit: (_) => setState(() => _hovered = false),
child: Listener(
onPointerDown: (_) => setState(() => _touched = true),
onPointerUp: (_) => setState(() => _touched = false),
onPointerCancel: (_) => setState(() => _touched = false),
// AnimatedContainer: un cambio de color ANIMADO (200 ms)
child: AnimatedContainer(
duration: const Duration(milliseconds: 200),
color: _touched || _hovered ? widget.color : Colors.transparent,
child: widget.child,
),
),
);
}
}
|
- líneas 32–34: [MouseRegion] notifica cuando el mouse entra o sale del widget (en la web o en una computadora; un teléfono no tiene mouse);
- líneas 35–38: [Listener] notifica, al más bajo nivel, cada toque con el dedo (o cada clic): presionar, soltar, cancelar;
- líneas 40–42: un [Container] animado: cuando cambia su color, pasa del color anterior al nuevo en 200 milisegundos, sin necesidad de código adicional. [Flutter] tiene toda una familia de estos widgets “animados implícitamente”: [AnimatedOpacity], [AnimatedPadding], [AnimatedAlign]...
[Highlighter] aplica su comportamiento a cualquier hijo: [Highlighter(child: ListTile(...))].
| // =========================================================================
// lib/ex15_behaviors/long_press.dart - un botón de pulsación larga
// -------------------------------------------------------------------------
// LongPressButton(duration: Duration(seconds: 1), onAction: remove, child: ...)
// La acción solo se ejecuta si el botón se mantiene presionado durante
// toda la duración: una protección contra pulsaciones accidentales. Un anillo
// se llena durante la pulsación.
// El llenado es una ANIMACIÓN: un AnimationController produce un
// valor que va de 0 a 1 durante la duración indicada, en cada fotograma de
// la pantalla. Necesita un "ticker" (el latido de los fotogramas): el mixin
// SingleTickerProviderStateMixin lo agrega al objeto State. Un MIXIN es
// la forma que tiene Dart de reutilizar código en varias clases (ver
// autofocus.dart).
// =========================================================================
import 'package:flutter/material.dart';
class LongPressButton extends StatefulWidget {
final Duration duration;
final VoidCallback onAction;
final Widget child;
const LongPressButton({
super.key,
this.duration = const Duration(seconds: 1),
required this.onAction,
required this.child,
});
@override
State<LongPressButton> createState() => _LongPressButtonState();
}
// "with": el objeto State recibe, además, el código del mixin
class _LongPressButtonState extends State<LongPressButton> with SingleTickerProviderStateMixin {
late final AnimationController _animation;
@override
void initState() {
super.initState();
// vsync: this: el ticker proporcionado por el mixin
_animation = AnimationController(vsync: this, duration: widget.duration)
// el fin de la animación: la pulsación duró lo suficiente
..addStatusListener((status) {
if (status == AnimationStatus.completed) {
_animation.reset();
widget.onAction();
}
});
}
// cuando se elimina el widget: sin animaciones huérfanas
@override
void dispose() {
_animation.dispose();
super.dispose();
}
void _start() => _animation.forward(from: 0);
// el dedo se levanta demasiado pronto: el anillo se vacía
void _stop() {
if (_animation.isAnimating) _animation.reverse();
}
@override
Widget build(BuildContext context) {
return GestureDetector(
onTapDown: (_) => _start(),
onTapUp: (_) => _stop(),
onTapCancel: _stop,
// AnimatedBuilder: reconstruye SOLO esta parte, en cada fotograma
child: AnimatedBuilder(
animation: _animation,
builder: (context, child) => Row(
mainAxisSize: MainAxisSize.min,
children: [
SizedBox(
width: 22,
height: 22,
child: CircularProgressIndicator(value: _animation.value, strokeWidth: 3, color: Colors.red),
),
const SizedBox(width: 8),
child!, // el hijo, construido una sola vez
],
),
child: widget.child,
),
);
}
}
|
- línea 35: [with]: el objeto [State] también recibe el código de un mixin. Un mixin es la manera en que [Dart] reutiliza código entre varias clases sin herencia. Este mixin proporciona un “ticker” (la frecuencia de actualización de la pantalla, 60 cuadros por segundo o más), que toda animación requiere;
- líneas 42–47: un [AnimationController] genera, en cada cuadro, un valor que va de 0 a 1 durante la duración especificada. [vsync: this]: el ticker proporcionado por el mixin. [..addStatusListener(...)]: cuando la animación llega al final ([completed]), la pulsación ha durado lo suficiente: la animación se restablece a cero y se ejecuta la acción;
- líneas 59–63: el dedo toca el botón: la animación parte de 0; si lo levanta demasiado pronto, la animación retrocede;
- líneas 69–71: gestos: presionar, soltar, cancelar (el dedo se ha deslizado fuera del botón);
- líneas 73–87: [AnimatedBuilder] reconstruye solo esta porción de la pantalla en cada cuadro de la animación: un anillo ([CircularProgressIndicator]) cuyo valor corresponde a la animación. El elemento fijo (el texto del botón) se construye una sola vez ([child]) y se pasa a [builder].
4.6.3. Un comportamiento en un mixin
| // =========================================================================
// lib/ex15_behaviors/autofocus.dart - un comportamiento en un MIXIN
// -------------------------------------------------------------------------
// La segunda forma de reutilizar un comportamiento: un mixin sobre State.
// class _MyPageState extends State<MyPage> with FocusOnStart { ... }
// El objeto State recibe un FocusNode (startFocus), que toma el foco
// en cuanto se muestra la pantalla, y que se libera con ella: el mixin
// completa el initState y el dispose de la clase que lo usa.
// "on State<T>": este mixin solo se aplica a un objeto State, cuyos
// métodos puede por tanto usar (initState, dispose, mounted...).
// (Para un campo simple, el parámetro autofocus: true de TextField hace
// lo mismo: el mixin muestra el mecanismo, reutilizable para otra cosa.)
// =========================================================================
import 'package:flutter/widgets.dart';
mixin FocusOnStart<T extends StatefulWidget> on State<T> {
final startFocus = FocusNode();
@override
void initState() {
super.initState(); // el initState de la clase (o del mixin) "superior"
// tras la primera visualización: el campo existe, se le da el foco
WidgetsBinding.instance.addPostFrameCallback((_) {
if (mounted) startFocus.requestFocus();
});
}
@override
void dispose() {
startFocus.dispose();
super.dispose();
}
}
|
- línea 17: un mixin que se aplica solo a un objeto [State] ([on State<T>]): por lo tanto, puede usar sus métodos;
- línea 18: el objeto [State] que usa el mixin recibe este campo;
- líneas 21–25: el mixin [initState] se completa: [super.initState()] llama al de la clase “padre” (la de [State], u otro mixin). Después de la visualización inicial, el campo existe: se le da el foco. [mounted]: ¿el objeto [State] sigue en el árbol?;
- líneas 30–32: también completa [dispose], para liberar [FocusNode].
4.6.4. Uso
| // =========================================================================
// lib/ex15_behaviors/main.dart - reutilizar comportamientos
// -------------------------------------------------------------------------
// Tres herramientas de Flutter y Dart para reutilizar un COMPORTAMIENTO (y
// su estado), y no una simple visualización:
// - un widget "envoltorio" (Highlighter);
// - un widget que lleva una animación (LongPressButton);
// - un mixin sobre State (FocusOnStart).
// =========================================================================
import 'package:flutter/material.dart';
import 'long_press.dart';
import 'autofocus.dart';
import 'highlighter.dart';
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const BehaviorsPage(),
),
);
}
class BehaviorsPage extends StatefulWidget {
const BehaviorsPage({super.key});
@override
State<BehaviorsPage> createState() => _BehaviorsPageState();
}
// el mixin FocusOnStart: este objeto State recibe startFocus
class _BehaviorsPageState extends State<BehaviorsPage> with FocusOnStart {
final List<String> _doctors = ['Mme Marie PELISSIER', 'Mr Paul TATOU', 'Melle Sophie DUPONT'];
String _message = '';
void _remove(String name) {
setState(() {
_doctors.remove(name);
_message = '$name has been deleted.';
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Example 15 - reusing behaviors')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
TextField(
focusNode: startFocus, // el FocusNode proporcionado por el mixin
decoration: const InputDecoration(hintText: 'this field received the focus on its own'),
),
const SizedBox(height: 12),
const Text(
'Touch the rows; hold a button pressed for one second to delete.',
style: TextStyle(color: Colors.grey),
),
for (final (i, m) in _doctors.indexed)
Highlighter(
key: ValueKey(m),
// una fila de cada dos: el color por defecto; las demás, verdes
color: i.isEven ? const Color(0xFFFFF3CD) : const Color(0xFFD1E7DD),
child: ListTile(
title: Text(m),
trailing: LongPressButton(
onAction: () => _remove(m),
child: const Text('Delete', style: TextStyle(color: Colors.red)),
),
),
),
const SizedBox(height: 12),
if (_message.isNotEmpty) Text(_message, style: const TextStyle(color: Colors.indigo)),
],
),
);
}
}
|
- línea 35: la pantalla utiliza el mixin;
- línea 54: el [FocusNode] proporcionado por el mixin;
- líneas 63–71: cada línea se resalta al tocarla; su botón “Delete” solo surte efecto después de mantenerlo presionado durante un segundo.
Mientras se mantiene presionado el primer botón (el anillo se llena, la línea se resalta); luego, tras presionar por completo el segundo botón:
4.7. Ejemplo 16: una ventana de confirmación reutilizable
“¿Está seguro?”: [Flutter] proporciona todo lo necesario. La función [showDialog] muestra una ventana modal sobre la pantalla y devuelve un [Future], completado con el valor que transmite la ventana al cerrarse.
4.7.1. La ventana
| // =========================================================================
// lib/ex16_confirmation/confirmation.dart - "¿Está seguro?"
// -------------------------------------------------------------------------
// Flutter proporciona todo lo necesario: showDialog() muestra un diálogo
// MODAL sobre la pantalla, y devuelve un Future, resuelto con el valor
// que el diálogo pasa al cerrarse: Navigator.pop(context, value).
// El código que lo llama se escribe, por tanto, de forma muy sencilla:
//
// if (await confirm(context, 'Delete this doctor?')) { ... }
//
// Cerrar el diálogo SIN responder (toque fuera, botón Atrás del
// teléfono, tecla Esc) resuelve el Future con null: se trata
// como un "no".
// =========================================================================
import 'package:flutter/material.dart';
Future<bool> confirm(BuildContext context, String message) async {
final answer = await showDialog<bool>(
context: context,
// AlertDialog: un diálogo Material, con un título, un contenido y botones
builder: (context) => AlertDialog(
title: const Text('Confirmation'),
content: Text(message),
actions: [
// autofocus: el botón "No" (la opción menos peligrosa) tiene el foco
TextButton(autofocus: true, onPressed: () => Navigator.pop(context, false), child: const Text('No, go back')),
FilledButton(
style: FilledButton.styleFrom(backgroundColor: Colors.red),
onPressed: () => Navigator.pop(context, true),
child: const Text('Yes, confirm'),
),
],
),
);
return answer ?? false; // null: diálogo cerrado sin respuesta
}
|
- línea 18: una función estándar que puede usarse en cualquier lugar donde haya un [context] disponible;
- líneas 19–22: [showDialog] abre la ventana creada por [builder] y devuelve un [Future<bool?>]: el valor transmitido cuando se cierra la ventana;
- líneas 23–25: [AlertDialog] es el cuadro de diálogo de [Material Design]: un título, contenido y botones;
- línea 27: [Navigator.pop(context, false)] cierra la ventana transmitiendo [false]. [autofocus]: el botón “No” (la opción menos riesgosa) tiene el foco (presionar Enter por accidente no elimina nada);
- línea 36: cerrar la ventana SIN responder (tocar fuera de la ventana, presionar el botón Atrás del teléfono o presionar la tecla Esc) resuelve el [Future] con [null]: se trata como un “no”.
El código que la llama es entonces tan sencillo de escribir como con [window.confirm] del navegador: [if (await confirm(context, 'Delete this doctor?')) { ... }]. El cliente [React] requería un contexto, una promesa hecha a mano y un “portal” para lograr el mismo resultado; con [Flutter], así es como funcionan normalmente las ventanas.
4.7.2. Uso
| // =========================================================================
// lib/ex16_confirmation/main.dart - usar el diálogo de confirmación
// -------------------------------------------------------------------------
// Una eliminación, y luego un mensaje efímero en la parte inferior de la pantalla (SnackBar),
// con un botón "Undo": la otra forma, muy común en celulares, de
// proteger al usuario de un error.
// =========================================================================
import 'package:flutter/material.dart';
import 'confirmation.dart';
typedef Contact = ({int id, String name});
void main() {
runApp(
MaterialApp(
debugShowCheckedModeBanner: false,
theme: ThemeData(colorSchemeSeed: Colors.indigo),
home: const ContactsPage(),
),
);
}
class ContactsPage extends StatefulWidget {
const ContactsPage({super.key});
@override
State<ContactsPage> createState() => _ContactsPageState();
}
class _ContactsPageState extends State<ContactsPage> {
final List<Contact> _contacts = [
(id: 1, name: 'Jean MARTIN'),
(id: 2, name: 'Alice DURAND'),
(id: 3, name: 'Luc GERMAN'),
];
String _message = '';
// una función async: "espera" la respuesta del usuario
Future<void> _remove(Contact c) async {
final yes = await confirm(context, 'Delete the contact ${c.name}?');
// después de un await, la pantalla puede haber desaparecido: comprobamos que sigue ahí
if (!mounted) return;
if (!yes) {
setState(() => _message = 'Deletion abandoned.');
return;
}
final position = _contacts.indexOf(c);
setState(() {
_contacts.remove(c);
_message = '${c.name} has been deleted.';
});
// ScaffoldMessenger: muestra un mensaje efímero en la parte inferior de la pantalla
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(
content: Text('${c.name} deleted'),
action: SnackBarAction(
label: 'Undo',
onPressed: () => setState(() {
_contacts.insert(position, c);
_message = '${c.name} is back.';
}),
),
),
);
}
Future<void> _removeAll() async {
final yes = await confirm(context, 'Delete the ${_contacts.length} contacts?');
if (yes && mounted) {
setState(() {
_contacts.clear();
_message = 'All the contacts have been deleted.';
});
}
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Example 16 - a confirmation dialog')),
body: ListView(
padding: const EdgeInsets.all(16),
children: [
for (final c in _contacts)
ListTile(
leading: const Icon(Icons.person),
title: Text(c.name),
trailing: IconButton(
icon: const Icon(Icons.delete_outline, color: Colors.red),
onPressed: () => _remove(c),
),
),
if (_contacts.isEmpty)
const ListTile(
title: Text('No contact.', style: TextStyle(color: Colors.grey)),
),
const SizedBox(height: 12),
Align(
alignment: Alignment.centerLeft,
child: FilledButton(
style: FilledButton.styleFrom(backgroundColor: Colors.red),
// null: botón deshabilitado cuando la lista está vacía
onPressed: _contacts.isEmpty ? null : _removeAll,
child: const Text('Delete all'),
),
),
const SizedBox(height: 12),
if (_message.isNotEmpty) Text(_message, style: const TextStyle(color: Colors.indigo)),
],
),
);
}
}
|
- líneas 41–44: una función [async]: espera la respuesta del usuario. Después de un [await], la pantalla puede haber desaparecido (el usuario se fue): verificamos que el usuario siga allí ([mounted]) antes de modificar el estado o de llamar a [context]. El analizador señala si se omitió esta verificación;
- líneas 55–62: después de la eliminación, aparece un mensaje temporal en la parte inferior de la pantalla ([SnackBar]), con un botón “Undo” que restaura el contacto en su posición original. Es otro método, muy común en los dispositivos móviles, para proteger al usuario de un error: actuar de inmediato, pero permitir deshacer la acción;
- línea 105: [null] deshabilita el botón cuando la lista está vacía.
La ventana de confirmación; luego la eliminación se completa, con su mensaje fugaz: