Jornada Flutter
void main() => runApp(
PessoaApp(
nome: 'Cácio Costa',
empresa: 'Alura',
cargo: 'Instrutor e pagodeiro nas horas vagas',
),
);Jornada
-
Introdução ao Flutter e configuração de ambiente
-
Fundamentos do Dart
-
Widgets fundamentais do Flutter
-
Navegação e rotas
-
Leiautes e media
-
Gerenciamento de estado
-
Integração com APIs e armazenamento local
-
Animações e transições
-
Testes, depuração e melhores práticas
-
Desenvolvimento cross-platform com Flutter

Seria legal se você...
-
... programa orientado a objetos (JavaScript melhor ainda).
-
... entende o protocolo HTTP e API REST.
-
... tem noção de SQL.
-
... conhece HTML e CSS.

Aula 1
Introdução ao Flutter
1
O que é o
Flutter
2
Ferramentas e ambiente de desenvolvimento
3
Como criar e organizar um projeto
5
Desafio
4
Árvore de Widgets
O que é o Flutter?

-
Framework open source para a construção de (não somente) aplicativos
-
Baseado em widgets
-
Permite criar aplicativos para Android e iOS
-
Criado pelo Google em 2017
Como era antes do Flutter?

-
Plataformas com arquiteturas próprias
-
O aplicativo tem que ser compilado para a plataforma específica
-
Duas SDKs (Xcode e Android SDK)
-
Bases de códigos distintas, com linguagens distintas
Por que usar Flutter?

-
A mesma base de código gera aplicativos para ambas plataformas
-
Curva de aprendizado menor
-
Mesma equipe de desenvolvimento
-
Novas plataformas (web e desktop)
-
SDKs de cada plataforma ainda é necessário
class MyApp extends StatelessWidget {
const MyApp({super.key});
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
colorScheme: ColorScheme.fromSeed(seedColor: Colors.amber),
useMaterial3: true,
),
home: const MyHomePage(title: 'Flutter Demo Home Page'),
);
}
}O que preciso saber?
Dart
-
Tipos, variáveis e funções
-
Orientação a objetos
-
Estruturas de dados (listas, maps, ...)
-
Assincronismo (Future)
-
Programação funcional*
Ferramentas necessárias
Intellij IDEA + plugins
do Flutter e Dart
VS Code + Flutter extension
Android Studio + Flutter Plugin
OU
OU
IDE
E
Dart
Flutter
Linguagem e framework
Xcode (iOS)
Android SDK
E
OU
SDKs das plataformas
Virtual
+
Ambiente de desenvolvimento
IDE
- importar o projeto
- executar
3.
Flutter
- adicionar no PATH
- flutter doctor
- flutter create
1.
SDK da plataforma
- Xcode
- iniciar emulador
2.
Mão na massa...
Estrutura do projeto

Diretórios e arquivos:
-
lib: fica o código fonte do projeto
-
test: testes automatizados
-
build: onde são geradas as construções
-
android, ios, macos, web, windows: arquivos específicos de cada plataforma
-
pubspec.yaml: arquivo de configuração do projeto (definir dependências, assets e outras configurações
-
main.dart: arquivo de entrada do aplicativo
Qual a árvore mais famosa da programação?
A árvore do HTML! 😜
A lógica do Flutter

Assim como um documento HTML é organizado numa árvore de tags, um aplicativo em Flutter é organizado como uma árvore de widgets!"
Árvore de widgets
- Aplicativo tem um widget raiz como ponto de entrada
- Alguns widgets suportam só um filho
TUDO É WIDGET!
Biblioteca de widgets: https://docs.flutter.dev/ui/widgets

void main() {
runApp(
Text('Hello, World!', textDirection: TextDirection.ltr),
);
}
Widgets
-
Blocos de construção (você constrói a interface com eles)
-
Descrevem como a UI deve ser de acordo com sua configuração e estado
-
Inspirados no React
-
Visual e comportamento é um único lugar
void main() {
runApp(
Center(
child: Text('Hello, World!', textDirection: TextDirection.ltr),
),
);
}
Widgets com único filho
Center e Container
void main() {
runApp(
Center(
child: Container(color: Colors.purple, height: 200, width: 200),
),
);
}
Column(
children: [
Container(color: Colors.purple, height: 100, width: 100),
Container(color: Colors.deepPurpleAccent, height: 100, width: 100),
],
);
Widgets com vários filhos
Column e Row
Row(
children: [
Container(color: Colors.purple, height: 100, width: 100),
Container(color: Colors.deepPurpleAccent, height: 100, width: 100),
],
);
Mão na massa...
Não precisa decorar (tudo)
Biblioteca de widgets: https://docs.flutter.dev/ui/widgets
-
Montar ambiente e implementar a tela ao lado sabendo que:
-
O primeiro quadrado tem lado 150 e a cor é deepPurple;
-
O segundo quadrado tem lado 120 e a cor é deepPurpleAccent;
-
O terceiro quadrado tem lado 150 e a cor é purple.
-
-
Pesquise pelo widget Stack no catálogo de widgets do Flutter.
Desafio

Nossas aulas
Próxima
Aula 1
24/06 às 10h
→ Introdução ao Flutter e Configuração do Ambiente
Atual
Aula 2
24/06 às 14h
→ Fundamentos do Dart
Aula 2
Fundamentos do Dart
1
Características do
Dart
2
Sintaxe
básica
3
Null
Safety
5
Orientação a
Objetos
4
Funções e
parâmetros
6
Assincronismo
7
Desafio
O que é Dart
O que é o Dart?
- Desenvolvida pelo Google
- Otimizada para o desenvolvimento web e móvel
- Compilação Ahead-of-Time (AOT)
- Desempenho Consistente, inicialização rápida e eficiência de memória
- Just-in-Time (JIT)
- Otimizações dinâmicas, ideal para desenvolvimento
-
Multiparadigma
- Orientação a objetos e funcional
Curiosidade: Foi criada para superar as limitações do JavaScript e melhorar a performance das aplicações web.
Sintaxe básica
Tipagem e main
/*
* A função main é o ponto de entrada de uma aplicação Dart.
*/
void main() { // blocos delimitados por chaves
// Indentação com dois espaços
print("Meu primeiro programa em Dart.");
// Estaticamente tipada
int titulosEmCopa = 5;
double idhBrasil = 0.759;
String nome = "Brasil";
// Tem inferência de tipos
var palmeirasTemMundial = false;
print(palmeirasTemMundial.runtimeType); // bool
print('O Palmeiras tem ' + (palmeirasTemMundial ? 'um' : 'nenhum') + ' mundial.');
// Interpolação de strings
print('O $nome tem $titulosEmCopa títulos de Copa do Mundo e um IDH de $idhBrasil.');
}Sintaxe básica
Padrão de codificação e nomenclatura
// Classes e enums em PascalCase
class PlanoTelefonico {
}
enum TipoPlano { basico, premium }
// Constantes em MAIÚSCULAS_COM_UNDERLINE
const double TAXA_ADESAO = 99.99;
// Variáveis, funções e parâmetros em camelCase
void calcularTarifaPlano(String nomePlano, String cliente) {
var valorMensal = 50.0;
// Indentação com 2 espaços
// Linhas com limite de 80 caracteres.
if (nomePlano == 'Vivo Pós 40GB com Netflix' && cliente == 'Cácio') {
darDescontoEspecial(99.99, cliente);
// Espaço antes das chaves dos blocos e nos parâmetros
}
}Condicionais e laços
IF - ELSE
if (minutosDeLigacao > 100) {
print('Você ultrapassou o limite de minutos.');
} else if (minutosDeLigacao > 50) {
print('Você está perto de atingir o limite de minutos.');
} else {
print('Você está dentro do limite de minutos.');
}
for (int i = 0; i < 5; i++) {
print('Canal $i: ${canais[i]}');
}
int contador = 0;
while (contador < 5) {
print('Promoção ativa para o plano $plano');
contador++;
}
FOR - WHILE
Condicionais e laços
Switch, switch expressions e exhaustiveness checking
String plano = 'Premium';
switch (plano) {
case 'Basico':
print('Plano Básico: Acesso limitado aos canais.');
case 'Premium':
print('Plano Premium: Acesso a todos os canais.');
default:
print('Plano desconhecido.');
}
String descricaoPlano = switch (plano) {
case 'Basico' => 'Plano Básico: Acesso limitado aos canais.',
case 'Premium' => 'Plano Premium: Acesso a todos os canais.',
default => 'Plano desconhecido.',
};
print(descricaoPlano);
enum TipoPlano { basico, premium, executivo }
TipoPlano tipo = TipoPlano.premium;
// Dart garante que todos os casos sejam cobertos
switch (plano) {
case TipoPlano.basico:
print('Plano Básico: Acesso limitado aos canais.');
case TipoPlano.premium:
print('Plano Premium: Acesso a todos os canais.');
case TipoPlano.executivo:
print('Plano Executivo: Benefícios exclusivos.');
}
Null Safety
Declaração e atribuição
// Não pode ser nulo
String nomeAssinante = 'Ana';
nameAssinante = null; ❌
// Pode ser nulo
String? planoAssinante = 'Premium';
planoAssinante = null; ✅
-
Null é uma das principais causas de falhas em tempo de execução
-
Variável nula deve ser explicitamente declarada
Null Safety
Operadores
// (??) -> Null Coalescing Operator
String? nomePlano;
String escolhido = nomePlano ?? 'Vivo Pós';
print(escolhido); // Saída: Vivo Pós
// (??=) -> Null Coalescing Assignment Operator
List<String>? canais = ['HBO', 'ESPN', 'Warner'];
canais ??= ['Globo', 'SBT', 'Record'];
print(canais); // Saída: [HBO, ESPN, Warner]
// (?.) -> Conditional Access Operator
String? assinante;
// Não lança exceção, apenas retorna null
print(assinante?.length);
// (!) -> Null Assertion Operator
print(assinante!); // Lança uma exceção se assinante for nuloFunções
Definição e parâmetros posicionais
void exibirLogo() {
print('Sou a logo da VIVO');
}
exibirLogo(); // invoca função
// Os dois parâmetros são obrigatórios
void realizarAssinatura(String nome, String plano) {
print('Cliente $nome assinou o plano $plano');
}
// Passa parâmetros pela posição
realizarAssinatura('Bia', 'Ultra HD');-
Precisa especificar o tipo de retorno
-
void quer dizer que não retorna valor
-
-
Parâmetros posicionais:
-
são obrigatórios
-
não podem ter valor padrão
-
Funções
Parâmetros nomeados
double calculaDesconto(
double valorDoPlano,
{ String? categoria, bool comFidelidade = false }
) {
double desconto = 0.0;
if (categoria == 'V') {
desconto = 0.2;
} else if (categoria == 'Platinum') {
desconto = 0.15;
} else if (categoria == 'Gold') {
desconto = 0.10;
}
if (comFidelidade) {
desconto += 0.05;
}
return valorDoPlano - (valorDoPlano * desconto);
}-
São opcionais por padrão, a menos que estejam anotados com required
-
Podem receber valor padrão
-
Podem ser passados em qualquer ordem
double calculaDesconto(
double valorDoPlano,
{ String? categoria, bool comFidelidade = false }
) {
// código omitido
}
var descontoZero = calculaDesconto(100);
var descontoV = calculaDesconto(100, categoria: 'V');
var descontoFidelidade = calculaDesconto(100, comFidelidade: true);
var descontoPlatinum = calculaDesconto(100, categoria: 'Platinum', comFidelidade: true);Funções
Função anônima
List<String> canais = ['SporTV', 'HBO', 'Warner'];
/*
* Função anônima (lambda) passada como argumento.
* Repare que ela tem corpo delimitado por chaves.
*/
canais.forEach((String canal) {
print(canal);
});
// Lambda com uma linha pode usar arrow ( => )
canais.forEach((String canal) => print(canal));-
Podem ter bloco delimitado por chaves
-
Lambdas com uma linha podem usar expression body (arrow =>)
Orientação a objetos
Classes, atributos e construtores
// Definição de classe com keywork class
class Assinante {
// atributos
String nome;
String plano;
// Generative construtor
Assinante(this.nome, this.plano);
@override
String toString() => 'Nome: $nome, Plano: $plano';
}
var assinante = Assinante('Ana', 'Básico');
print(assinante); // 'Nome: Ana, Plano: Básico
assinante.plano = 'Premium';
print(assinante.plano); // Premium-
Atributos não nulos precisam ser inicializados
-
Generative constructor é um atalho para inicializar os atributos
-
valem as mesmas regras de atributos posicionais e nomeados das funções
-
-
Atributos geram getter e setter (quando pertinente) implícitos
Orientação a objetos
Encapsulamento e construtores nomeados
class Celular {
String _marca;
String _modelo;
String _numero;
// Getters
String get marca => _marca;
String get modelo => _modelo;
String get numero => _numero;
// Setters
set marca(String novaMarca) => _marca = novaMarca;
set modelo(String novoModelo) => _modelo = novoModelo;
set numero(String novoNumero) => _numero = novoNumero;
// Construtor nomeado usando Initializing List
Celular.fromJson(Map<String, dynamic> json)
: _marca = json['marca'],
_modelo = json['modelo'],
_numero = json['numero'];
@override
String toString() => 'Celular{_marca: $_marca, _modelo: $_modelo, _numero: $_numero}';
}
Map<String, String> json = {
'marca': 'Vivo',
'modelo': 'Xiaomi Mi 11',
'numero': '11987654321'
};
Celular celular = Celular.fromJson(json);
print(celular);
celular.marca = 'Samsung';
celular.modelo = 'Galaxy S21';
celular.numero = '11912345678';
print(celular);-
Atributos com prefixo `_` são privados
-
Use get e set para criar métodos acessores
-
Dart suporta construtores nomeados que inicializam os atributos (initializing list)
Orientação a objetos
Herança
class Plano {
String nome;
Plano(this.nome);
}
/*
* Palavra chave EXTENDS permite
* usar herança no Dart.
*/
class PlanoFamilia extends Plano {
int membros;
PlanoFamilia(String nome, this.membros) : super(nome);
void mostrarInfo() {
print('Plano: $nome, Membros: $membros');
}
}
PlanoFamilia planoFamilia = PlanoFamilia('Vivo Família', 4);Processamento assíncrono
Future
// Simulando uma operação assíncrona de verificação de crédito
Future<String> verificarCredito() {
return Future.delayed(Duration(seconds: 3), () {
return 'Crédito aprovado';
});
}
void main() {
print('Verificando crédito do cliente...');
verificarCredito()
.then((status) {
print('Status do crédito: $status');
});
}- Assincronismo permite realizar operações sem bloquear o fluxo principal do programa
- Future representa um valor ou erro que estará disponível no futuro
- quando o valor estiver disponível, invoca o callback passado no then
Processamento assíncrono
Async await
// Repare na palavra ASYNC
Future<String> verificarCredito() async {
await Future.delayed(Duration(seconds: 3));
return 'Crédito verificado';
}
void main() async {
print('Verificando crédito do cliente...');
String status = await verificarCredito();
print('Status do crédito: $status');
}- Async/await facilitam a escrita de códigos que possuem assincronismo
-
Crie uma classe
PlanoInternetcom os seguintes atributos privados:nome,velocidade e preco; -
Implemente um construtor para inicializar esses atributos.
-
Crie métodos para:
-
Exibir as informações do plano
-
-
Utilize getters e setters para encapsular os dados.
Desafio
Nossas aulas
Anterior
Próxima
Aula 3
25/07 às 10h
Widgets fundamentais do Flutter
Atual
Aula 2
Fundamentos do Dart
Aula 1
Introdução ao Flutter
Aula 3
Widgets fundamentais do Flutter
1
Tour por vários
widgets
2
Stateless
Widget
3
Stateful
Widget
4
Desafio
void main() {
runApp(
MaterialApp(
home: Text('Hello World'),
),
);
}
MaterialApp
Column
-
Widget raiz de um aplicativo que segue o Material Design
-
Fornece estrutura básica e configurações essenciais
-
Permite navegação entre telas
-
Aplica as diretrizes do Material Design
-
e mais...
/**
* Representa o esqueleto de uma tela
* (AppBar, body, FloatActionButton, Drawer,
* BottomNavigationBar, etc...)
*/
void main() {
runApp(
MaterialApp(
home: Scaffold(
appBar: AppBar(
title: Text('Histórico de faturas'),
),
body: Center(
child: Text('Mensagem de dentro de um Scaffold')
),
)
),
);
}
Scaffold
Column

void main() {
runApp(
MaterialApp(
home: Scaffold(
appBar: AppBar(
title: Text('Histórico de faturas'),
),
/**
* CARD Representa um cartão de material design.
* Sombra, cantos arredondados.
* Diferente do Container, que tem propósito
* genérico.
*/
body: Card(
color: Colors.white,
/**
* ListTile exibe informações de forma
* organizada e interativa.
*/
child: ListTile(
leading: Icon(Icons.check_circle, color: Colors.green),
title: Text('Venceu em 25/01'),
subtitle: Text('Paga'),
trailing: Text("R\$ 149.00",
style: TextStyle(color: Colors.black, fontSize: 20.0)),
),
),
),
),
);
}
Card e ListTile
Column

Column(
children: [
Card(
color: Colors.white,
child: ListTile(
leading: Icon(Icons.watch_later_outlined, color: Colors.grey),
title: Text('Vence em 24/03'),
subtitle: Text('Aberta'),
trailing: Text("R\$ 153.00",
style: TextStyle(color: Colors.black, fontSize: 20.0)
),
),
),
Card(
color: Colors.white,
child: ListTile(
leading: Icon(Icons.watch_later_outlined, color: Colors.red),
title: Text('Venceu em 25/03'),
subtitle: Text('Atrasada'),
trailing: Text("R\$ 153.00",
style: TextStyle(color: Colors.black, fontSize: 20.0)
),
),
),
Card(
color: Colors.white,
child: ListTile(
leading: Icon(Icons.check_circle, color: Colors.green),
title: Text('Venceu em 25/02'),
subtitle: Text('Paga'),
trailing: Text("R\$ 146.00",
style: TextStyle(color: Colors.black, fontSize: 20.0)),
),
),
Card(
color: Colors.white,
child: ListTile(
leading: Icon(Icons.check_circle, color: Colors.green),
title: Text('Venceu em 25/01'),
subtitle: Text('Paga'),
trailing: Text("R\$ 149.00",
style: TextStyle(color: Colors.black, fontSize: 20.0)),
),
),
],
);
Column (e Row)
Column

SingleChildScrollView(
child: Column(
children: [
Card(
color: Colors.white,
child: ListTile(
leading: Icon(Icons.watch_later_outlined, color: Colors.grey),
title: Text('Vence em 24/03'),
subtitle: Text('Aberta'),
trailing: Text("R\$ 153.00",
style: TextStyle(color: Colors.black, fontSize: 20.0)
),
),
),
// ... muitos outros Cards
],
),
);
Overflow e SingleChildScrollView
Column

void main() {
runApp(
Center(
child: Text(
'Olá, Mundo Flutter!',
textDirection: TextDirection.ltr,
),
),
);
}
Widgets Próprios
-
Criados com widgets de baixo nível
-
Retornam a representação visual no método build
-
Podem encapsular uma lógica de apresentação
-
Trazem semântica e reaproveitamento
-
Estendem StatelessWidget ou StatefulWidget
void main() {
runApp(OlaMundo());
}
class OlaMundo extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Center(
child: Text('Olá, Mundo Flutter!', textDirection: TextDirection.ltr),
);
}
}

StatelessWidget
-
Não rastreiam valores ao longo do ciclo de vida
-
Não atualizam a tela com mudanças de estado
-
Encapsulam uma lógica de apresentação
-
Geralmente são imutáveis
-
Reduzem código duplicado e melhoram a coesão

StatelessWidget
void main() {
runApp(
MaterialApp(
theme: ThemeData(useMaterial3: true),
home: Scaffold(
appBar: AppBar(
title: Text('Histórico de faturas'),
),
body: Column(
children: [
Card(
color: Colors.white,
child: ListTile(
leading: Icon(
Icons.watch_later_outlined,
color: Colors.grey,
),
title: Text('Vence em 24/03'),
subtitle: Text('Aberta'),
trailing: Text(
"R\$ 153.00",
style: TextStyle(color: Colors.black, fontSize: 20.0),
),
),
),
// ... demais Cards
],
),
),
),
);
}
void main() {
runApp(
MaterialApp(
theme: ThemeData(useMaterial3: true),
home: Scaffold(
appBar: AppBar(
title: Text('Histórico de faturas'),
),
body: Column(
children: [
CardFatura(153.0, '25/04', aberta: true,),
CardFatura(146.0, '25/03', atrasada: true),
CardFatura(146.0, '25/02'),
CardFatura(146.0, '25/02'),
],
),
),
),
);
}
class CardFatura extends StatelessWidget {
double valor;
String vencimento;
bool aberta;
bool atrasada;
CardFatura(this.valor, this.vencimento,
{this.aberta = false, this.atrasada = false, Key? key})
: super(key: key);
@override
Widget build(BuildContext context) {
String status = 'Paga';
Icon icone = Icon(Icons.check_circle, color: Colors.green);
if (atrasada) {
icone = Icon(Icons.watch_later_outlined, color: Colors.red);
status = 'Atrasada';
} else if (aberta) {
icone = Icon(Icons.error_outline, color: Colors.grey);
status = 'Aberta';
}
return Card(
color: Colors.white,
child: ListTile(
leading: icone,
title: Text('Venceu em $vencimento'),
subtitle: Text(status),
trailing: Text("R\$ ${valor.toStringAsFixed(2)}",
style: TextStyle(color: Colors.black, fontSize: 20.0)),
),
);
}
}

Mão na massa...
StatefulWidget
-
Possuem estado que muda com ações do usuário ou eventos externos
-
Repintam a tela para exibir o estado atualizado
-
Estado encapsulado numa classe separada do widget

StatefulWidget
class JogoDeDados extends StatefulWidget {
@override
JogoDeDadosState createState() => JogoDeDadosState();
}
class JogoDeDadosState extends State<JogoDeDados> {
String dado1 = '?';
String dado2 = '?';
@override
Widget build(BuildContext context) {
return Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Container( // Representa o primeiro dado
height: 100,
width: 100,
decoration: BoxDecoration(
color: Colors.white,
borderRadius: BorderRadius.circular(16),
),
child: Center(
child: Text(dado1, // Texto do dado 1
style: TextStyle(
fontSize: 50,
fontWeight: FontWeight.bold,
),
),
),
),
SizedBox(width: 8),
Container( // Representa o segundo dado
height: 100,
width: 100,
decoration: BoxDecoration(
color: Colors.white,
borderRadius: BorderRadius.circular(16),
),
child: Center(
child: Text(dado2, // Texto do dado 2
style: TextStyle(
fontSize: 50,
fontWeight: FontWeight.bold,
),
),
),
),
],
),
SizedBox(height: 24),
ElevatedButton(
onPressed: sorteia, // Precisa atualizar a tela
child: Text('Rolar dados'),
),
],
);
}
void sorteia() {
setState(() { // Autaliza o estado para atualizar a tela
dado1 = '${Random().nextInt(6) + 1}';
dado2 = '${Random().nextInt(6) + 1}';
});
}
}
Dúvida! Quem atualiza? A tela ou o dado? 🤔

A tela pode se atualizar com widgets stateless.
Pode ser stateless, reaproveitado e evitar código duplicado.
StatefulWidget + StatelessWidget
class JogoDeDados extends StatefulWidget {
@override
JogoDeDadosState createState() => JogoDeDadosState();
}
class JogoDeDadosState extends State<JogoDeDados> {
String dado1 = '?';
String dado2 = '?';
@override
Widget build(BuildContext context) {
return Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [Dado(dado1), SizedBox(width: 8), Dado(dado2)],
),
SizedBox(height: 24),
ElevatedButton(
onPressed: sorteia,
child: Text('Rolar dados'),
)
],
);
}
void sorteia() {
setState(() {
dado1 = '${Random().nextInt(6) + 1}';
dado2 = '${Random().nextInt(6) + 1}';
});
}
}
class Dado extends StatelessWidget {
final String numero;
const Dado(this.numero);
@override
Widget build(BuildContext context) {
return Container(
height: 100,
width: 100,
decoration: BoxDecoration(
color: Colors.white,
borderRadius: BorderRadius.circular(16),
boxShadow: [
BoxShadow(
color: Colors.black.withOpacity(0.2),
blurRadius: 6,
offset: Offset(0, 3),
),
],
),
child: Center(
child: Text(
numero,
style: TextStyle(
fontSize: 50,
fontWeight: FontWeight.bold,
),
),
),
);
}
}
- Crie os cards da seção Acesso rápido da tela inicial.
- Faça tanto o card maior quanto o menor
Desafio

Aula 4
Navegação e rotas
1
Estrutura de navegação do Flutter
2
Formas de
navegação
3
Passagem de parâmetros
4
Desafio
Como é a navegacão no Flutter?
Column
Tela 1
Tela 2
Tela 3
Tela N
push
push
push
pop
pop
pop
popUntil
Funciona como uma pilha!

Eu vejo Futures ao
mudar de tela
Com que frequência?
O tempo todo!
Navegação anônima
Mais simples e imperativas.
Formas de navegação
Navegação nomeada
Declaradas no atributo `router` de MaterialApp.
Navegação 2.0
Mais complexa e completa. Ideal para aplicativos web.
Rotas anônimas
- Mais fáceis de passar parâmetros
na navegação - Rotas ficam "escondidas" e
espalhadas pelo código - Usam MaterialPageRoute para
fazer a transição
Navegação
/**
* NAVIGATOR é o objeto responsável pela
* navegação no aplicativo.
*/
Navigator.of(context)
.push(MaterialPageRoute(
builder: (context) => TelaDeCobranca(),
));// Volta para a tela anterior
Navigator.of(context).pop();
Rotas nomeadas
- Rotas declaradas no MaterialApp
- São facilmente encontradas
- Passagem de parâmetros exige
casting - Não precisa do MaterialPageRoute
na navegação
Navegação
// Navegação mais simplificada
Navigator.of(context).pushNamed('/fatura');
Navigator.of(context).pop();
MaterialApp(
routes: {
'/': (context) => TelaInicial(),
'/faturas': (context) => ListagemDeFaturas(),
'/faturas/cobranca': (context) => CobrancaDeFatura(),
},
);
Rotas anônimas
- Diretamente no construtor da
nova tela - No método `pop` ao voltar para
a tela anterior
Passagem de parâmetros
Navigator.of(context)
.push(MaterialPageRoute(
builder: (context) => TelaDeCobranca(fatura),
))
.then((sucesso) => {
if (sucesso) {
retirarNomeDoSerasa();
} else {
tentarNovaNegociacao();
}
);// Em algum lugar em TelaDeCobranca
Navigator.of(context)
.pop(pagamentoRealizadoComSucesso);
Rotas nomeadas
- Diretamente no Navigator (Object)
- Parâmetros disponíveis em
ModalRoute - Precisa de casting
Passagem de parâmetros
Navigator.pushNamed(context, '/fatura/cobranca',
arguments: {'id': 42}
)
.then((sucesso) => {
if (sucesso) {
retirarNomeDoSerasa();
} else {
tentarNovaNegociacao();
}
);// Em algum lugar em TelaDeCobranca
final args = ModalRoute.of(context)!.settings.arguments as Map;
int id = args['id'];
Navigator.of(context)
.pop(pagamentoRealizadoComSucesso);
- Implementar a navegação do botão "Central de Faturas" para a central.
- OBS: Não precisa implementar toda a tela.
Desafio


Aula 5
Leiautes e media
1
Como usar
imagens no Flutter
2
Temas e
estilos
3
Componentes de leiaute avançados
4
Desafio
Imagens
Imagens
- Carrega imagens da internet via URL
- Problema se estiver sem conexão
- Bom para ambiente de desenvolvimento
Image.network
Image.network(
'https://pbs.twimg.com/media/Fwvbm_NWAAIpIOV?format=jpg&name=large',
width: 300,
height: 450,
);
Imagens
- Meio mais seguro
- Deixa o app maior
Image.asset
flutter:
# Tema que descomentar essa linha no
# adicionar os recursos
assets:
- assets/images/flu_serie_b.jpgImage.asset('assets/images/flu_serie_b.jpg');
pubspec.yaml
Imagens
- Carrega arquivo local do dispositivo
- Ideal para abrir da galeria de fotos ou
captura de câmera - Requer permissão
- Tipo `File
Image.file
- Exibe imagens carregadas em bytes na
memória - Útil para exibir imagens recuperadas de APIs
- Tipo `Uint8List`
Image.memory
Imagens
- Carrega arquivo local do dispositivo
- Ideal para abrir da galeria de fotos ou
captura de câmera - Requer permissão
- Tipo `File
Image.file
- Exibe imagens carregadas em bytes na
memória - Útil para exibir imagens recuperadas de APIs
- Tipo `Uint8List`
Image.memory
Temas
Estrutura do tema (M3)
MaterialApp(
title: 'Meu App',
theme: ThemeData(
useMaterial3: true,
),
home: MyHomePage(),
);
ThemeData
-
ThemeData encapsula as propriedades do tema
-
MaterialApp aplica o tema a todos os widgets descendentes.
-
`useMaterial3: true` para habilitar os novos componentes e estilos
Principais componentes
MaterialApp(
title: 'Meu App',
theme: ThemeData(
useMaterial3: true,
colorScheme: ColorScheme.fromSeed(seedColor: Color(0xFF8533AD)),
// Roxinho VIVO
),
home: MyHomePage(),
);
Cores e ColorScheme
-
Novo sistema de cores que facilita a criação de paletas dinâmicas
-
ColorScheme completo a partir de uma cor base (seed color)
-
Promove uma estética mais coesa
Principais componentes
MaterialApp(
title: 'Meu App',
theme: ThemeData(
useMaterial3: true,
colorScheme: ColorScheme.fromSeed(
seedColor: Color(0xFF8533AD)
// Roxinho VIVO
),
textTheme: TextTheme(
displayLarge: TextStyle(
fontSize: 32, fontWeight: FontWeight.bold
),
bodyLarge: TextStyle(
fontSize: 18, color: Colors.black87
),
),
),
home: MyHomePage(),
);
Tipografia e TextTheme
-
Nova abordagem de tipografia com TextTheme
-
Estilos flexíveis e consistentes.
Principais componentes
MaterialApp(
title: 'Meu App',
theme: ThemeData(
// ... configurações anteriores
appBarTheme: AppBarTheme(
backgroundColor: Color(0xFF8533AD),
titleTextStyle: TextStyle(
color: Colors.white, fontSize: 24
),
),
filledButtonTheme: FilledButtonThemeData(
style: ButtonStyle(
padding: WidgetStateProperty.all<EdgeInsetsGeometry>(
const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
),
),
),
home: MyHomePage(),
);
Temas de componentes específicos
-
Permite temas específicos a alguns componentes
-
`appBarTheme`, `filledButtonTheme`, etc...
Principais componentes
MaterialApp(
title: 'Meu App',
theme: ThemeData(
// Configurações do tema normal
),
darkTheme: ThemeData(
useMaterial3: true,
colorScheme: ColorScheme.fromSeed(
seedColor: Colors.red,
brightness: Brightness.dark,
),
),
themeMode: ThemeMode.dark,
// poder ser (light|system)
home: MyHomePage(),
);
Temas dinâmicos
-
Capacidade de usar cores dinâmicas
-
Adaptabilidade ao sistema operacional
-
Necessário configurar um outro ColorScheme e definir themeMode em MaterialApp
Usando tema nos widgets
Text(
'Olá, Flutter!',
style: Theme.of(context).textTheme.bodyLarge,
);
Theme.of(context)
-
Theme dá acesso ao tema adequado ao contexto do widget na árvore.
-
Reusa estilos e mantém consistência da identidade visual.
Leiautes avançados
Canais do youtube

- Criar tema para o aplicativo
Desafio



Aula 6
Gerenciamento de Estado
1
Ciclo de vida
do Stateful
2
Instalação de
dependências
3
Provider
4
Desafio
Permissão para mudar a rota...
🫡
Formulário

-
Sempre dentro de StatefulWidget
-
Preferência para TextFormField (suporte a validação)
-
Controlado com TextEditingController
-
-
Inputs dentro de Form para controlar estado/eventos do formulário
-
Form precisa de Key para recuperar facilmente o estado
Formulário de chamados

class FormularioNovoChamado extends StatefulWidget {
FormularioNovoChamado({super.key});
@override
State<FormularioNovoChamado> createState() => _FormularioNovoChamadoState();
}
class _FormularioNovoChamadoState extends State<FormularioNovoChamado> {
final campoTitulo = TextEditingController();
final campoDescricao = TextEditingController();
final _formKey = GlobalKey<FormState>();
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: const Text('Novo chamado'),
),
body: Padding(
padding: const EdgeInsets.all(16.0),
child: Form(
key: _formKey,
child: SingleChildScrollView(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('Título do chamado', style: TextStyle(fontSize: 28)),
TextFormField(
controller: campoTitulo,
decoration: InputDecoration(
hintText: 'Descreva o seu problema',
),
),
SizedBox(height: 40),
Text('Descreva o seu problema', style: TextStyle(fontSize: 28)),
TextFormField(
controller: campoDescricao,
decoration: InputDecoration(
hintText: 'Descreva o seu problema',
),
maxLines: 5,
),
SizedBox(height: 40),
Center(
child: FilledButton(
onPressed: () {
var chamado = criaChamado();
Navigator.of(context).pop(chamado);
},
child: const Text('Enviar chamado'),
),
),
],
),
),
),
)
);
}
Chamado criaChamado() {
return Chamado(
userId: 1,
titulo: campoTitulo.text,
dataDeAbertura: DateTime.now(),
descricao: campoDescricao.text,
);
}
}StatefulWidget++
Ciclo de vida
class CicloDeVida extends StatefulWidget {
const CicloDeVida({super.key});
@override
State<CicloDeVida> createState() => _CicloDeVidaState();
}
class _CicloDeVidaState extends State<CicloDeVida> {
/**
* Chamado uma única vez, então é o lugar ideal para
* inicializar atributos e realizar operações assíncronas.
*/
@override
void initState() { ... }
/**
* Responsável por construir a árvore de widgets.
* Também invocado sempre que o widget pai é reconstruído,
* ou quando o estado foi atualizado.
*/
@override
Widget build(BuildContext context) { ... }
/**
* Notifica que o estado interno mudou e a tela,
* a partir daquele widget, precisa ser reconstruída.
* Aciona invocação do método build.
*/
@override
void setState(VoidCallback fn) { ... }
/**
* Invocado quando o widget é removido da árvore. Usado
* para liberar recursos ou cancelar operações assíncronas.
*/
@override
void dispose() { ... }
}Mão-na-massa


FormularioDeLogin
Home
AcessoRapido
ListaDeChamados
FormularioNovoChamado
Prop drilling
Estado centralizado


Prop drilling
Estado centralizado
Provider
Instalação
ChangeNotifier
- Notifica interessados de que algo mudou
- Armazena o estado
Conceitos
ChangeNotifierProvider
- Provê acesso ao ChangeNotifier
- Deve ser colocado no último ancestral comum de onde o estado é necessário (geralmente é o APP)
Consumer
- Permite reconstruir um widget com base nos valores modificados do provider
- Deve ficar o mais baixo possível na árvore de widgets
watch e read
- Outra forma de acessar ler um estado ou reagir a mudanças nele
ChangeNotifier
class UsuarioProvider extends ChangeNotifier {
Usuario? usuario;
bool get isLogado => usuario != null;
void login(Usuario usuario) {
this.usuario = usuario;
notifyListeners();
}
void logout() {
this.usuario = null;
notifyListeners();
}
}-
Classe que guarda o estado compartilhado
-
Quando uma informação muda, precisa notificar os widgets (observadores)
ChangeNotifierProvider
class VivoApp extends StatelessWidget {
const VivoApp({super.key});
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
ChangeNotifierProvider(
create: (context) => UsuarioProvider()
),
],
child: MaterialApp(
title: 'Vivo App',
theme: TEMA_CLARO,
home: const FormularioDeLogin(),
debugShowCheckedModeBanner: false,
),
);
}
}-
ChangeNotifierProvider cria os providers somente quando requisitados
-
Pode-se ter vários providers configurados (MultiProvider)
-
MaterialApp construído com todos os providers configurados.
Context.watch
class Home extends StatelessWidget {
const Home({super.key});
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Vivo App'),),
body: Padding(
padding: EdgeInsets.all(8.0),
child: SingleChildScrollView(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Padding(
padding: const EdgeInsets.only(top: 24, bottom: 36),
child: RichText(
text: TextSpan(
text: 'Olá, ',
style: TextStyle(fontSize: 24, color: Colors.black),
children: [
/**
* Precisa tomar cuidado com o CONTEXT
* que está configurado o watch
*/
TextSpan(
text: context.watch<UsuarioProvider>().usuario!.nome,
style: TextStyle(fontWeight: FontWeight.bold),
),
],
),
),
),
PainelChamada(),
SizedBox(height: 48),
AcessoRapido(),
],
),
),
),
floatingActionButton: FloatingActionButton(
onPressed: () {
print('Floating action button clicado...');
},
child: const Icon(Icons.phone),
)
);
}
}Consumer<T>
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:vivoapp/models/usuario.dart';
import 'package:vivoapp/providers/usuario_provider.dart';
import 'package:vivoapp/widgets/acesso_rapido.dart';
import 'package:vivoapp/widgets/chamada.dart';
class Home extends StatelessWidget {
const Home({super.key});
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Vivo App'),),
body: Padding(
padding: EdgeInsets.all(8.0),
child: SingleChildScrollView(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Padding(
padding: const EdgeInsets.only(top: 24, bottom: 36),
child: Consumer<UsuarioProvider>(
builder: (
BuildContext context, // Contexto diferente para otimização
UsuarioProvider provider, // o provider com os dados
Widget? child // usado para otimização
) {
return RichText(
text: TextSpan(
text: 'Olá, ',
style: TextStyle(fontSize: 24, color: Colors.black),
children: [
TextSpan(
text: '${provider.usuario!.nome}.',
style: TextStyle(fontWeight: FontWeight.bold),
),
],
),
);
},
),
),
PainelChamada(),
SizedBox(height: 48),
AcessoRapido(),
],
),
),
),
floatingActionButton: FloatingActionButton(
onPressed: () {
print('Floating action button clicado...');
},
child: const Icon(Icons.phone),
)
);
}
}
Context.read
FilledButton(
onPressed: () {
/**
* Somente acessa, sem ser notificado de mudanças
*/
int id = context.read<UsuarioProvider>().usuario!.id;
var chamado = criaChamado(id);
Navigator.of(context).pop(chamado);
},
child: const Text('Enviar chamado'),
)Mão-na-massa
- Implementar formulário de login e disponibilizar usuário com provider.
- OBS: dados de login devem ser fictícios.
Desafio


Aula 7
Interação com APIs e Armazenamento Local
1
Integração via HTTP
2
Persistência com SharedPreferences
3
Desafio
Integração via HTTP
Obtendo dados da API
import 'package:http/http.dart' as http;
import 'dart:convert';
const String _BASE_URL = 'http://localhost:3000';
Future<List<Chamado>> listaChamados() async {
Uri uri = Uri.parse('$_BASE_URL/chamados');
http.Response resposta = await http.get(uri);
if (resposta.statusCode == 200) {
// Se for um objeto, seria Map<String, dynamic>
List<dynamic> listaJson = jsonDecode(resposta.body);
return listaJson.map((json) => Chamado.fromJson(json))
.toList();
} else {
debugPrint('ERRO: ${resposta.body}');
throw Exception('Erro ao buscar chamados');
}
}services/api.dart
Método GET
Convertendo em JSON
class Chamado {
// Demais meétodo e atributos
Chamado.fromJson(Map<String, dynamic> json)
: id = json['id'],
userId = json['userId'],
titulo = json['titulo'],
dataDeAbertura = DateTime.parse(json['dataDeAbertura']),
descricao = json['descricao'],
dataDeFechamento = json['dataDeFechamento'] != null
? DateTime.parse(json['dataDeFechamento'])
: null;
Map<String, dynamic> toJson() {
return {
'userId': userId,
'titulo': titulo,
'dataDeAbertura': dataDeAbertura.toIso8601String(),
'descricao': descricao,
'dataDeFechamento': dataDeFechamento?.toIso8601String(),
};
}
}models/chamado.dart
Serialização
-
Serialização é feita "na unha"
-
Dart não suporta reflection em tempo de execução
-
Há geradores de código (json_serializable) para quebrar o galho
-
Hoje é mais tranquilo com IA Generativa
Enviando dados para a API
Future<Chamado> cadastraChamado(Chamado chamado) async {
http.Response resposta = await http.post(
Uri.parse('$_BASE_URL/chamados'),
headers: <String, String>{
'Content-Type': 'application/json',
},
body: jsonEncode(chamado.toJson()),
);
if (resposta.statusCode == 201) {
return Chamado.fromJson(jsonDecode(resposta.body));
} else {
debugPrint('ERRO: ${resposta.body}');
throw Exception('Erro ao criar chamado');
}
}services/api.dart
Método POST
Listagem com API
class _ListaDeChamadosState extends State<ListaDeChamados> {
List<Chamado> _chamados = [];
// Demais métodos...
@override
void initState() {
super.initState();
carregaListaDeChamados();
}
void carregaListaDeChamados() async {
debugPrint('Buscando chamados');
_chamados = await listaChamados();
_chamados.sort(
(a, b) => b.dataDeAbertura.compareTo(a.dataDeAbertura)
);
setState(() {});
}
}screens/suporte/lista_chamados.dart
Inicializando estado
Cadastrando no formulário
// DEMAIS CÓDIGOS OMITIDOS
FilledButton(
onPressed: () {
String id = context.read<UsuarioProvider>().usuario!.id;
criaChamado(id).then(
(chamado) => Navigator.of(context).pop(chamado),
);
},
child: const Text('Enviar chamado'),
)
Future<Chamado> criaChamado(String userId) async {
return cadastraChamado(
Chamado(
userId: userId,
titulo: campoTitulo.text,
dataDeAbertura: DateTime.now(),
descricao: campoDescricao.text,
),
);
}screens/suporte/formulario_novo_chamado.dart
Inicializando estado
Armazenamento local
com SharedPreferences
Shared Preferences
Características
-
Plugin para armazenamento chave-valor (similar ao Storage API do navegador)
-
Dados são salvos no dispositivo do usuário
-
Pequeno volume de dados
-
Consistente am ambas plataformas

Shared Preferences
import 'package:shared_preferences/shared_preferences.dart';
Future<void> registraLogin(Usuario usuario) async {
var prefs = await SharedPreferences.getInstance();
await prefs.setBool('logado', true);
await prefs.setString('usuario', jsonEncode(usuario.toJson()));
}
Future<Usuario?> usuarioLogado() async {
var prefs = await SharedPreferences.getInstance();
var usuarioJson = prefs.getString('usuario');
if (usuarioJson == null) {
return null;
}
return Usuario.fromJson(jsonDecode(usuarioJson));
}
Future<void> limpaLogin() async {
var prefs = await SharedPreferences.getInstance();
await prefs.setBool('logado', false);
await prefs.remove('usuario');
}services/autenticacao.dart
Salvando e lendo dados
Mão-na-massa
- Implementar a listagem de faturas usando o pacote http.
- Use dados fictícios e simples
Desafio

Aula 8
Animações e Transições
1
Splash Screen
2
Conceitos elementais de animação
3
Animações
implícitas
4
Transição de
telas customizadas
5
Desafio
Splash Screen


Splash Screen
Nativo vs Flutter
-
Implementada nativamente fora do Flutter
-
Exibida enquanto o Flutter está carregando
-
Só aparece quando necessário
-
Obrigatória para apps no iOS
-
Implementada dentro do framework do Flutter
-
Apresentada depois do Flutter estar carregado
-
Exibida mesmo em warm start (processo do app é trazido para foreground)
Splash Screen Nativa
Tela de introdução Flutter
Native Splash Screen
flutter_native_splash:
android: true
ios: true
web: false
image: assets/images/logo_vivo.jpg
color: "#8533AD"pubspec.yaml
Configuração e geração
dart run flutter_native_splash:createterminal
Animações
Princípios básicos
A
B
Interpolação
(movimento de A para B)
(class Tween)
Princípios básicos
Animações implícitas
O que são?
-
Animação que ocorre quando um atributo do widget muda
-
Basta indicar a duração (e a curva, preferencialmente) que o Flutter controla
-
Fáceis de usar
-
Existem vários prontos (AnimatedXpto) 🥳
-
Usos: expandir/colapsar menus, seleção de elementos, esmaecer, transições suaves entre telas, etc...

AnimatedContainer
/**
* CardChamado virou stateful
*/
class _CardChamadoState extends State<_CardChamado> {
bool selecionado = false;
Icon? icone;
@override
void initState() {
super.initState();
icone = widget._chamado.fechado
? const Icon(Icons.check_circle, color: Colors.green)
: const Icon(Icons.error_outline, color: Colors.grey);
}
@override
Widget build(BuildContext context) {
return GestureDetector(
onTap: () => setState(() => selecionado = !selecionado),
/**
* Trocou Container por AnimatedContainer,
* configurou curva e duração, e pronto!
*/
child: AnimatedContainer(
duration: const Duration(milliseconds: 300),
curve: Curves.fastLinearToSlowEaseIn,
padding: const EdgeInsets.symmetric(vertical: 8),
decoration: BoxDecoration(
color: selecionado
? Colors.grey.shade300
: Colors.white,
border: Border(
bottom: BorderSide(color: Colors.grey.shade300),
),
),
// Demais configurações do container omitidas
),
);
}screens/suporte/lista_chamados.dart

AnimatedOpacity
class _AvisoDeFaturasState extends State<AvisoDeFaturas> {
double opacidade = 1;
bool removerAviso = false;
void removeAviso() {
setState(() => opacidade = 0);
Future.delayed(Duration(milliseconds: 800), () {
setState(() => removerAviso = true);
});
}
@override
Widget build(BuildContext context) {
return Visibility(
visible: !removerAviso,
child: AnimatedOpacity(
duration: const Duration(milliseconds: 800),
curve: Curves.easeOutQuad,
opacity: opacidade,
child: Wrap(
runSpacing: 20,
children: [
Text(
'Você tem prontas para pagar. Quer pagar agora?',
style: TextStyle(fontSize: 28),
),
FilledButton(onPressed: () {}, child: Text('Pagar faturas')),
TextButton(
onPressed: removeAviso,
child: Text('Ocultar notificação'),
),
],
),
),
);
}
}screens/home.dart

AnimatedAlign
Outros exemplos...
AnimatedCrossFade
AnimatedSize
AnimatedList
Hero
...
Transições de tela
Transição de tela
Route rotaDeslizante(Widget tela) {
/**
* Dispensa o MaterialPageRoute (quem fazia a animação
* da transição e construía a página para inserir na tela).
*/
return PageRouteBuilder(
pageBuilder:
(context, animation, secondaryAnimation) => tela,
transitionDuration: const Duration(milliseconds: 500),
transitionsBuilder: (
context, animation, secondaryAnimation, child
) {
const begin = Offset(-1, 0);
const end = Offset.zero;
const curve = Curves.ease;
var tween = Tween(begin: begin, end: end)
.chain(CurveTween(curve: curve));
final offsetAnimation = animation.drive(tween);
return SlideTransition(
position: offsetAnimation,
child: child,
);
},
);
}widgets/util.dart

Sobrescrevendo a transição
Transição de tela
context.read<UsuarioProvider>()
.login(usuario)
.then((_) {
Navigator.of(context)
.pushReplacement(
rotaDeslizante(const Home())
);
});widgets/util.dart

Usando o PageRouteBuilder
- Implementar a seção Especiais pra você com o o pacote carousel_slider.
- Use a mesma imagem e chamada; o foco é a animação. 😉
Desafio

Aula 9
Testes e boas práticas
1
Tipos de teste
no Flutter
2
Escrever
testes
3
Boas (más) práticas
4
Desafio
Quem nunca fez um teste automatizado, levanta a mão. 🤚🏼

Testes de unidade
- Não dependem de recursos externos
- Mais fáceis de escrever e rápidos de executar
Testes no Flutter
Testes de Widgets
- Flutter oferece mecanismos para controlar (e interagir com) widgets
- Mais lentos e difíceis de criar
- Pacote flutter_test
Testes de integração
- Foco em testar o aplicativo como um todo (GUI testing)
- É possível executar no target device e no host machine
- Pacote integration_test
Teste de unidade
Teste de widget
Boas práticas
- Implemente um caso de teste para a Central de faturas que verifique se tem uma fatura aberta, uma atrasada e duas pagas.
Desafio

Aula 10
Desenvolvimento Cross-Platform com Flutter
1
Desafios
2
Considerações
sobre interface
3
Interação com
código nativo
4
Estado atual das
novas plataformas
Vantagens e desafios
Vantagens
Alcance de Público Amplo
Consistência de Experiência do Usuário
Economia de Tempo e Recursos
Desafios
Compatibilidade e Adaptação
Limitações de Desempenho
Limitações de API nativa
Considerações
Adaptação de Interface: Consistência entre iOS, Android e Web
Usar elementos específicos da plataforma
Experiência direcionada




Cupertino
Material
Padronização + interação + feedback
Consistência de design
-
Diretrizes de design
-
disposição de elementos, navegação, gestos, etc
-
-
Espaçamento e alinhamento
-
+ que simples estética → usabilidade e harmonia
-
SizedBox e Padding
-
-
Testes de usabilidade
-
Feedback de usuários (insights de melhoria, etc)
-
Gerenciamento de
Dependências
Method Channel
Dependências nativas
- Habilita aplicativo interagir diretamente com código nativo
- Possibilita instalar e usar dependências nativas

1 - Dependência da plataforma
Method channel - Etapas
// build.gradle
dependencies {
implementation 'com.example:your-library:1.0.0'
}
# Podfile
pod 'YourLibrary', '~> 1.0'
2 - Código nativo
Method channel - Etapas
public class MainActivity extends FlutterActivity {
private static final String CHANNEL = "com.example/native";
@Override
public void configureFlutterEngine(FlutterEngine flutterEngine) {
super.configureFlutterEngine(flutterEngine);
new MethodChannel(
flutterEngine.getDartExecutor().getBinaryMessenger(),
CHANNEL
)
.setMethodCallHandler(
(call, result) -> {
if (call.method.equals("getData")) {
// Chame sua biblioteca aqui
String data = getNativeData();
result.success(data);
} else {
result.notImplemented();
}
}
);
}
}
2 - Código nativo
Method channel - Etapas
import UIKit
import Flutter
@UIApplicationMain
class AppDelegate: FlutterAppDelegate {
override func application(
_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions:
[UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
let controller = window?.rootViewController as! FlutterViewController
let channel = FlutterMethodChannel(name: "com.example/native",
binaryMessenger: controller.binaryMessenger)
channel.setMethodCallHandler { (call, result) in
if call.method == "getData" {
let data = self.getNativeData() // Chame sua biblioteca aqui
result(data)
} else {
result(FlutterMethodNotImplemented)
}
}
return super.application(application, didFinishLaunchingWithOptions: launchOptions)
}
}
3 - Ponte de comunicação
Method channel - Etapas
import 'package:flutter/services.dart';
class NativeBridge {
static const MethodChannel _channel = MethodChannel('com.example/native');
Future<String> getNativeData() async {
final String data = await _channel.invokeMethod('getData');
return data;
}
}
void fetchData() async {
String data = await NativeBridge().getNativeData();
print(data);
}
Considerações
Method Channels
-
Por quê?
-
Implementar algo que não tem no Flutter
-
Acessar recursos específicos da plataforma (sensor, câmera, etc)
-
Reusar dependência nativa
-
-
Cuidados
-
Compatibilidade e Manutenção 🏋🏼
-
Web e Desktop com Flutter
Panorama
Web e Desktop
-
-
Versão Beta
-
Responsividade, PWA e canvas (algumas renderizações)
-
Desempenho, SEO e tamanho do bundle final
-
-
-
Versão Alpha
-
Renderização de alto desempenho, mais possibilidade de periféricos, etc
-
Estabilidade, recursos ainda indisponíveis, documentação
-





Obrigado
(def pessoa {:nome "Cácio José da Costa Silva"
:linkedin "/cacio-costa/"
:email "cacio.costa@alura.com.br"
:repo "https://github.com/cacio-costa/vivoapp"
:ig-grupo-qdqa "@grupoqdqa"})Jornada Flutter
By cacio-costa
Jornada Flutter
- 128

