Jornada Flutter

void main() => runApp(
  PessoaApp(
    nome: 'Cácio Costa',
    empresa: 'Alura',
    cargo: 'Instrutor e pagodeiro nas horas vagas',
  ),
);

Jornada

  1. Introdução ao Flutter e configuração de ambiente

  2. Fundamentos do Dart

  3. Widgets fundamentais do Flutter

  4. Navegação e rotas

  5. Leiautes e media

  6. Gerenciamento de estado

  7. Integração com APIs e armazenamento local

  8. Animações e transições

  9. Testes, depuração e melhores práticas

  10. 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!

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)

  1. 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.

  2. ​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 nulo

Funçõ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 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.

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.jpg
Image.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:create

terminal  

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"})
Made with Slides.com