void main() => runApp(
PessoaApp(
nome: 'Cácio Costa',
empresa: 'Alura',
cargo: 'Instrutor e pagodeiro nas horas vagas',
),
);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
... 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
O que é o
Flutter
Ferramentas e ambiente de desenvolvimento
Como criar e organizar um projeto
Desafio
Árvore de Widgets
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
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
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'),
);
}
}Dart
Tipos, variáveis e funções
Orientação a objetos
Estruturas de dados (listas, maps, ...)
Assincronismo (Future)
Programação funcional*
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
+
IDE
Flutter
SDK da plataforma
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
Assim como um documento HTML é organizado numa árvore de tags, um aplicativo em Flutter é organizado como uma árvore de widgets!"
TUDO É WIDGET!
Biblioteca de widgets: https://docs.flutter.dev/ui/widgets
void main() {
runApp(
Text('Hello, World!', textDirection: TextDirection.ltr),
);
}
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),
),
);
}
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),
],
);
Column e Row
Row(
children: [
Container(color: Colors.purple, height: 100, width: 100),
Container(color: Colors.deepPurpleAccent, height: 100, width: 100),
],
);
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.
Aula 1
24/06 às 10h
→ Introdução ao Flutter e Configuração do Ambiente
Aula 2
24/06 às 14h
→ Fundamentos do Dart
Aula 2
Características do
Dart
Sintaxe
básica
Null
Safety
Orientação a
Objetos
Funções e
parâmetros
Assincronismo
Desafio
O que é o Dart?
Curiosidade: Foi criada para superar as limitações do JavaScript e melhorar a performance das aplicações web.
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.');
}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
}
}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
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.');
}
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
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 nuloDefiniçã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
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çã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 =>)
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); // PremiumAtributos 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
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)
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);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');
});
}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');
}Crie uma classe PlanoInternet com 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.
Aula 3
25/07 às 10h
Widgets fundamentais do Flutter
Aula 2
Fundamentos do Dart
Aula 1
Introdução ao Flutter
Aula 3
Tour por vários
widgets
Stateless
Widget
Stateful
Widget
Desafio
void main() {
runApp(
MaterialApp(
home: Text('Hello World'),
),
);
}
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')
),
)
),
);
}
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)),
),
),
),
),
);
}
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
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
],
),
);
Column
void main() {
runApp(
Center(
child: Text(
'Olá, Mundo Flutter!',
textDirection: TextDirection.ltr,
),
),
);
}
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),
);
}
}
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
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)),
),
);
}
}
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
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}';
});
}
}A tela pode se atualizar com widgets stateless.
Pode ser stateless, reaproveitado e evitar código duplicado.
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,
),
),
),
);
}
}Aula 4
Estrutura de navegação do Flutter
Formas de
navegação
Passagem de parâmetros
Desafio
Column
Tela 1
Tela 2
Tela 3
Tela N
push
push
push
pop
pop
pop
popUntil
Eu vejo Futures ao
mudar de tela
Com que frequência?
O tempo todo!
Navegação anônimaMais simples e imperativas.
Navegação nomeadaDeclaradas no atributo `router` de MaterialApp.
Navegação 2.0Mais complexa e completa. Ideal para aplicativos web.
/**
* 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();
// Navegação mais simplificada
Navigator.of(context).pushNamed('/fatura');
Navigator.of(context).pop();
MaterialApp(
routes: {
'/': (context) => TelaInicial(),
'/faturas': (context) => ListagemDeFaturas(),
'/faturas/cobranca': (context) => CobrancaDeFatura(),
},
);
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);
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);
Aula 5
Como usar
imagens no Flutter
Temas e
estilos
Componentes de leiaute avançados
Desafio
Image.networkImage.network(
'https://pbs.twimg.com/media/Fwvbm_NWAAIpIOV?format=jpg&name=large',
width: 300,
height: 450,
);Image.assetflutter:
# 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
Image.fileImage.memoryImage.fileImage.memoryMaterialApp(
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
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
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.
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...
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
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.
Aula 6
Ciclo de vida
do Stateful
Instalação de
dependências
Provider
Desafio
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
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,
);
}
}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() { ... }
}FormularioDeLogin
Home
AcessoRapido
ListaDeChamados
FormularioNovoChamado
Prop drilling
Estado centralizado
ChangeNotifierChangeNotifierProviderConsumerwatch e readclass 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)
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.
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),
)
);
}
}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),
)
);
}
}
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'),
)Aula 7
Integração via HTTP
Persistência com SharedPreferences
Desafio
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
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
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
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
// 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
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
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
Aula 8
Splash Screen
Conceitos elementais de animação
Animações
implícitas
Transição de
telas customizadas
Desafio
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
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
A
B
Interpolação
(movimento de A para B)
(class Tween)
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...
/**
* 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
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
AnimatedAlignAnimatedCrossFadeAnimatedSizeAnimatedListHero...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
context.read<UsuarioProvider>()
.login(usuario)
.then((_) {
Navigator.of(context)
.pushReplacement(
rotaDeslizante(const Home())
);
});widgets/util.dart
Usando o PageRouteBuilder
Aula 9
Tipos de teste
no Flutter
Escrever
testes
Boas (más) práticas
Desafio
Testes de unidadeTestes de WidgetsTestes de integraçãoAula 10
Desafios
Considerações
sobre interface
Interação com
código nativo
Estado atual das
novas plataformas
Alcance de Público Amplo
Consistência de Experiência do Usuário
Economia de Tempo e Recursos
Compatibilidade e Adaptação
Limitações de Desempenho
Limitações de API nativa
Usar elementos específicos da plataforma
Cupertino
Material
Padronização + interação + feedback
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)
Method Channel
1 - Dependência da plataforma
// build.gradle
dependencies {
implementation 'com.example:your-library:1.0.0'
}
# Podfile
pod 'YourLibrary', '~> 1.0'
2 - Código nativo
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
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
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
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 🏋🏼
Panorama
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
(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"})