/*
 * 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.');
}

// 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 (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++;
}

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.');
}

// Não pode ser nulo
String nomeAssinante = 'Ana';
nameAssinante = null; ❌

 // Pode ser nulo
String? planoAssinante = 'Premium';
planoAssinante = null; ✅

// (??) -> 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

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');

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));

// 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

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);

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);

// 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');
    });
}

// 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');
}

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}';
    });
  }
}

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,
          ),
        ),
      ),
    );
  }
}

/**
 * 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();

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);

Image.network(
  'https://pbs.twimg.com/media/Fwvbm_NWAAIpIOV?format=jpg&name=large',
  width: 300,
  height: 450,
);

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');

MaterialApp(
  title: 'Meu App',
  theme: ThemeData(
    useMaterial3: true,
  ),
  home: MyHomePage(),
);

MaterialApp(
  title: 'Meu App',
  theme: ThemeData(
    useMaterial3: true,
    colorScheme: ColorScheme.fromSeed(seedColor: Color(0xFF8533AD)),
                                                   // Roxinho VIVO
  ),
  home: MyHomePage(),
);

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(),
);

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(),
);

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(),
);

Text(
  'Olá, Flutter!',
  style: Theme.of(context).textTheme.bodyLarge,
);

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() { ... }
}

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();
  }

}

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,
      ),
    );

  }
}

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'),
)

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');
  }
}

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(),
    };
  }
            
}

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');
  }
}

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(() {});
  }

}

// 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,
    ),
  );
}

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');
}

flutter_native_splash:
  android: true
  ios: true
  web: false

  image: assets/images/logo_vivo.jpg
  color: "#8533AD"

dart run flutter_native_splash:create

/**
 * 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
      ),
    );
    
}

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'),
            ),
          ],
        ),
      ),
    );
  }
}

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,
      );
    },
  );
}

context.read<UsuarioProvider>()
  .login(usuario)
  .then((_) {
  
    Navigator.of(context)
      .pushReplacement(
        rotaDeslizante(const Home())
      );
      
  });

// build.gradle
dependencies {
    implementation 'com.example:your-library:1.0.0'
}

# Podfile
pod 'YourLibrary', '~> 1.0'

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();
                }
            }
        );
    }
}

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)
    }
}

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);
}

(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"})

function MenuList() {
  return (
    <nav>
      <ul>
        {itemsMenu.map((menuItem, index) => (
          <li key={index}>
            <a href={menuItem.link}>{menuItem.item}</a>
          </li>
        ))}
      </ul>
	</nav>
  )
}

function Botao(props) {
  return (
    <button onClick={props.onClick}>
      {props.texto}
    </button>
  )
}

function Input(props) {
  return (
    <input
      value={props.value}
      onChange={props.onChange}
      placeholder={props.placeholder}
    />
  )
}

function Lista(props) {
  return (
    <ul>
      {props.itens.map(item => (
        <li key={item.id}>{item.nome}</li>
      ))}
    </ul>
  )
}

function App() {
  const [texto, setTexto] = React.useState('')
  const [itens, setItens] = React.useState([])
  const adicionarItem = () => {
    const novoItem = { id: itens.length + 1, nome: texto }
    setItens([...itens, novoItem])
    setTexto('')
  }

  return (
    <div>
      <h1>Minha Lista</h1>
      <Input
        value={texto}
        onChange={e => setTexto(e.target.value)}
        placeholder="Digite um item"
      />
      <Botao onClick={adicionarItem} texto="Adicionar" />
      <Lista itens={itens} />
    </div>
  )
}

ReactDOM.createRoot(document.getElementById('root')).render(
  <App />
)

function Botao(props) {
  const handleClick = () => {
    props.onClick()
  }

  return (
    <button className={`btn ${props.className}`} onClick={handleClick}>
      {props.texto}
    </button>
  )
}

class Welcome extends React.Component { 
   render() { 
      return <h1>Hello, Vivo!</h1> 
   }
}

import React, { Component } from 'react'

export class Input extends Component {
  handleChange = (event) => {
    this.props.onChange(event)
  }

  render() {
    return (
      <input
        className={`input ${this.props.className}`}
        value={this.props.value}
        onChange={this.handleChange}
        placeholder={this.props.placeholder}
      />
    )
  }
}

import React, { Component } from 'react'

class Contador extends Component {
  constructor(props) {
    super(props);
    this.state = {
      contagem: 0
    }
  }

  incrementar = () => {
    this.setState((prevState) => ({
      contagem: prevState.contagem + 1
    }))
  }

  render() {
    return (
      <div>
        <h1>Contagem: {this.state.contagem}</h1>
        <button onClick={this.incrementar}>Incrementar</button>
      </div>
    )
  }
}

export default Contador

function OlaMundo() { 
  return <h1>Olá, mundo!</h1>
}

function Botao(props) {
  return (
    <button onClick={props.onClick}>
      {props.texto}
    </button>
  )
}

export default Botao