Entendendo a navegação inferior no Flutter
A navegação inferior em apps mobile é popular porque nossos celulares continuam ficando maiores, mas nossos polegares não. Veja como fazer isso no Flutter.
A navegação inferior em apps mobile é popular porque nossos celulares continuam ficando maiores, mas nossos polegares não. A especificação do Material Design descreve uma barra de navegação inferior como uma linha de três a cinco botões na parte de baixo da tela, usados para selecionar entre o mesmo número de destinos.
O Flutter oferece um widget BottomNavigationBar que é basicamente uma linha de botões de destino e um único callback que recebe o índice do botão tocado. Tudo o que o app precisa fazer é reconstruir com um widget de “view de destino” correspondente ao botão que o usuário tocou. Simples. Há até um exemplo curto que demonstra isso na documentação da API. Então, terminamos?
Se fosse tão simples assim.
Views de destino com estado
Views de destino tendem a ter estado. Elas podem conter campos de texto, controles de seleção, áreas roláveis ou outros widgets que dependem de um estado que não deve ser descartado quando o usuário seleciona outro destino. Em outras palavras, quando o usuário volta a um destino, a view de destino deve estar exatamente como ele a deixou.
Uma implementação trivial da navegação inferior, em que apenas a view de destino selecionada faz parte da árvore de widgets, não preserva o estado das outras views de destino. A forma mais simples de garantir que o estado de todas as views seja preservado é manter todas elas na árvore de widgets, mostrando apenas a view selecionada. Felizmente, existe um widget para isso.
Um IndexedStack exibe apenas um de seus filhos. Todos os filhos estão sempre na árvore de widgets, então o estado deles nunca é descartado.
Para demonstrar o uso de um IndexedStack na exibição do destino selecionado, criei algumas pequenas classes de apoio e variáveis.
A classe Destination contém algumas propriedades visuais que identificam um destino. Também há uma lista dos quatro destinos do app, allDestinations.
class Destination {
const Destination(this.title, this.icon, this.color);
final String title;
final IconData icon;
final MaterialColor color;
}
const List<Destination> allDestinations = <Destination>[
Destination('Home', Icons.home, Colors.teal),
Destination('Business', Icons.business, Colors.cyan),
Destination('School', Icons.school, Colors.orange),
Destination('Flight', Icons.flight, Colors.blue)
];
Cada DestinationView com estado contém um TextField para demonstrar que o foco do teclado e o valor do campo de texto persistem ao trocar de destino. Cada DestinationView tem seu próprio scaffold. Para não ser detalhista demais: estamos aninhando scaffolds aqui. Tudo bem.
class DestinationView extends StatefulWidget {
const DestinationView({ Key key, this.destination }) : super(key: key);
final Destination destination;
@override
_DestinationViewState createState() => _DestinationViewState();
}
class _DestinationViewState extends State<DestinationView> {
TextEditingController _textController;
@override
void initState() {
super.initState();
_textController = TextEditingController(
text: 'sample text: ${widget.destination.title}',
);
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text('${widget.destination.title} Text'),
backgroundColor: widget.destination.color,
),
backgroundColor: widget.destination.color[100],
body: Container(
padding: const EdgeInsets.all(32.0),
alignment: Alignment.center,
child: TextField(controller: _textController),
),
);
}
@override
void dispose() {
_textController.dispose();
super.dispose();
}
}
Por fim, chegamos ao ponto de todo este exercício: a HomePage, que apresenta um scaffold com um BottomNavigationBar para os destinos, e um IndexedStack para as views de destino. Como você pode ver, ao tocar em um destino (em um BottomNavigationBarItem), a home page é reconstruída com um novo valor para _currentIndex. O indexed stack exibe a view de destino selecionada pelo índice atual.
class HomePage extends StatefulWidget {
@override
_HomePageState createState() => _HomePageState();
}
class _HomePageState extends State<HomePage> with TickerProviderStateMixin<HomePage> {
int _currentIndex = 0;
@override
Widget build(BuildContext context) {
return Scaffold(
body: SafeArea(
top: false,
child: IndexedStack(
index: _currentIndex,
children: allDestinations.map<Widget>((Destination destination) {
return DestinationView(destination: destination);
}).toList(),
),
),
bottomNavigationBar: BottomNavigationBar(
currentIndex: _currentIndex,
onTap: (int index) {
setState(() {
_currentIndex = index;
});
},
items: allDestinations.map((Destination destination) {
return BottomNavigationBarItem(
icon: Icon(destination.icon),
backgroundColor: destination.color,
title: Text(destination.title)
);
}).toList(),
),
);
}
}
E pronto: agora você tem navegação inferior com views de destino com estado. Todo mundo está feliz.

Na verdade, nem todo mundo está feliz. A especificação do Material Design deixa claro que as views de destino devem surgir com uma transição de cross fade. A demo do indexed stack simplesmente encaixa o destino selecionado na tela em um único frame. A especificação também sugere que, se uma view de destino for rolável, a barra de navegação inferior pode, opcionalmente, sair da tela quando o usuário rolar para cima, e reaparecer apenas quando ele rolar para baixo. E, por fim, há a navegação: muitos apps exigem que cada view de destino seja hospedada pelo próprio Navigator, para que a view possa exibir uma pilha de rotas em vez de uma única página interativa.
As seções a seguir vão deixar todo mundo feliz. Mais feliz.
Um Navigator por view de destino
Um Navigator do Flutter gerencia uma pilha de objetos Route e uma pilha de overlays exibidos por cima. Rotas não são widgets: são objetos que possuem um widget. O widget de uma rota pode ser uma página totalmente opaca ou uma parte de interface menor, como um diálogo ou um menu.
Uma discussão completa sobre navigators e rotas está além do escopo deste artigo. Para ajudar você a entender a versão da demo em que cada view de destino inclui um navigator, aqui estão alguns fatos a ter em mente:
Navigators têm os métodos push e pop para gerenciar a pilha de rotas.
-
Navigators suportam a criação preguiçosa de rotas. Rotas criadas de forma preguiçosa são identificadas por um nome de caminho.
Por padrão, o navigator exibe a rota chamada ‘/’.
-
Qualquer widget pode empilhar ou desempilhar rotas no seu navigator ancestral com os métodos estáticos Navigator.push e Navigator.pop.
O código a seguir é uma versão do estado da view de destino que constrói um navigator em vez de apenas construir um campo de texto. As rotas são construídas de forma preguiçosa pelo callback onGenerateRoute, e o widget de cada rota é construído por um callback builder do MaterialPageRoute.
class _DestinationViewState extends State<DestinationView> {
@override
Widget build(BuildContext context) {
return Navigator(
onGenerateRoute: (RouteSettings settings) {
return MaterialPageRoute(
settings: settings,
builder: (BuildContext context) {
switch(settings.name) {
case '/':
return RootPage(destination: widget.destination);
case '/list':
return ListPage(destination: widget.destination);
case '/text':
return TextPage(destination: widget.destination);
}
},
);
},
);
}
}
O widget RootPage trata os toques empilhando a rota chamada ‘/list’, que contém um widget ListPage:
onTap: () {
Navigator.pushNamed(context, "/list");
},
O widget ListPage é parecido. Tocar em qualquer item da lista faz com que ele empilhe uma rota ‘/text’, que conterá um widget TextPage. O TextPage é essencialmente o mesmo que o DestinationView original (ele contém um único TextField).

Cross fade entre views de destino
A ideia básica aqui é bem simples: empilhar as views de destino, fazer surgir a view selecionada e apagar as views não selecionadas. Quando um destino terminar de desaparecer, vamos movê-lo para Offstage, para que ele não seja mais renderizado nem receba toques. Para garantir que mover as views para offstage preserve o estado delas, dê a cada uma uma Global Key.
Uma breve explicação sobre global keys e a preservação do estado de um widget.
Toda vez que a árvore de widgets é reconstruída, o Flutter preserva o estado dos widgets que ocupam o mesmo lugar na árvore e têm a mesma key que no frame anterior. A maioria dos widgets é criada sem key, então esse teste se resume a: mesmo tipo em runtime e mesma posição na árvore. Um widget com global key é tratado de forma diferente. Seu estado e sua subárvore são movidos se o widget com a key tiver mudado de lugar quando a árvore for reconstruída.
Esta versão da demo exige algum estado adicional da HomePage para cada view de destino: uma animação de fade e uma global key.
List<AnimationController> _faders;
List<Key> _destinationKeys;
int _currentIndex = 0;
@override
void initState() {
super.initState();
_faders = allDestinations.map<AnimationController>((Destination destination) {
return AnimationController(vsync: this, duration: Duration(milliseconds: 200));
}).toList();
_faders[_currentIndex].value = 1.0;
_destinationKeys = List<Key>.generate(allDestinations.length, (int index) => GlobalKey()).toList();
}
@override
void dispose() {
for (AnimationController controller in _faders)
controller.dispose();
super.dispose();
}
Na versão de cross fade da demo, o indexed stack original foi substituído por um Stack comum, em que cada view de destino foi envolvida por um FadeTransition e recebeu uma global key com um KeyedSubtree. Cada transição de fade é controlada por um dos animation controllers da lista _faders mostrada acima.
O fader do destino selecionado é executado para frente, o que faz a view surgir. Os faders das outras views são executados em reverso, e aquelas que já desapareceram por completo são movidas para offstage. Enquanto uma view está desaparecendo, ela é envolvida por um IgnorePointer, para que não responda aos gestos do usuário.
Stack(
fit: StackFit.expand,
children: allDestinations.map((Destination destination) {
final Widget view = FadeTransition(
opacity: _faders[destination.index].drive(CurveTween(curve: Curves.fastOutSlowIn)),
child: KeyedSubtree(
key: _destinationKeys[destination.index],
child: DestinationView(
destination: destination,
),
),
);
if (destination.index == _currentIndex) {
_faders[destination.index].forward();
return view;
} else {
_faders[destination.index].reverse();
if (_faders[destination.index].isAnimating) {
return IgnorePointer(child: view);
}
return Offstage(child: view);
}
}).toList(),
)
Isso é tudo sobre o cross fade. Fica evidente que seria fácil trocar o fade por outra transição.

Ocultando a barra de navegação inferior ao rolar
Nesta versão da demo, qualquer view de destino com conteúdo rolável faz a barra de navegação inferior sair da tela quando o conteúdo é rolado para baixo, e voltar quando o conteúdo rola para cima. Vamos usar um
NotificationListener<ScrollNotification>
na raiz de cada view de destino para detectar mudanças na direção da rolagem. Envolver a barra de navegação inferior com um
SizeTransition
torna possível animar a barra para entrar e sair da tela.
Esta versão da demo exige adicionar mais um animation controller, para mostrar e ocultar a barra de navegação inferior, no estado da view de destino:
// ...
AnimationController _hide;
@override
void initState() {
super.initState();
// ...
_hide = AnimationController(vsync: this, duration: kThemeAnimationDuration);
}
@override
void dispose() {
// ...
_hide.dispose();
super.dispose();
}
Quando a direção da rolagem muda, o callback da notificação de rolagem executa o animation controller _hide para frente, para ocultar a barra de navegação inferior, e em reverso, para mostrá-la. Usamos a depth da notificação para distinguir o scrollable mais externo dos aninhados.
O size transition mantém o filho da barra de navegação alinhado ao topo enquanto ela cresce e encolhe, ao especificar axisAlignment como -1.
bool _handleScrollNotification(ScrollNotification notification) {
if (notification.depth == 0) {
if (notification is UserScrollNotification) {
final UserScrollNotification userScroll = notification;
switch (userScroll.direction) {
case ScrollDirection.forward:
_hide.forward();
break;
case ScrollDirection.reverse:
_hide.reverse();
break;
case ScrollDirection.idle:
break;
}
}
}
return false;
}
Widget build(BuildContext context) {
return NotificationListener<ScrollNotification>(
onNotification: _handleScrollNotification,
child: Scaffold(
// ...
bottomNavigationBar: SizeTransition(
sizeFactor: _hide,
axisAlignment: -1.0,
child: BottomNavigationBar(
// ...
),
),
),
);
}
Isso é praticamente tudo para adicionar suporte à mudança de visibilidade da barra de navegação inferior quando o destino atual é rolado. Se você ler o código-fonte da demo completa, vai ver um ajuste adicional. Sempre que o navigator de uma view de destino empilha ou desempilha uma nova rota, a barra de navegação inferior é exibida. Isso é feito dando a cada navigator de view de destino um NavigatorObserver, que garante que a barra de navegação inferior esteja visível.

Resumo
Este artigo explica como criar um app com barra de navegação inferior usando Flutter. O efeito é semelhante à navegação por abas na web, com as abas embaixo: cada aba (ou “destino”) seleciona uma view que oferece uma pilha de navegação.
Além do widget BottomNavigationBar, a implementação da demo usa os widgets Stack, Navigator, IgnorePointer e Offstage para gerenciar as views de destino, os widgets SizeTransition e FadeTransition para animação, e os widgets NotificationListener e NavigatorObserver para acompanhar as mudanças de estado.
Este artigo é baseado em uma palestra que dei no NYC Flutter Meetup em 22/5/2019.
Muitos dos exemplos dependem do Flutter 1.7.1 ou de uma versão mais recente.