Ciclo de vida, assincronia e Dart II

No fim desta aula consegues

• Descrever os estados de uma app móvel (foreground, background, suspensa, morta) e o que o sistema operativo faz em cada transição.
• Explicar porque um cálculo pesado bloqueia a interface e o que são os 16 ms por frame.
• Escrever código assíncrono em Dart com Future, async/await, tratamento de erros e Stream.
• Converter JSON em objetos Dart e vice-versa com fromJson e toJson.
• Usar enums com valores e métodos, e extension methods em tipos que não são teus.

Estados de uma app

Para os testes: em segundo plano a app pode ser morta a qualquer momento e sem aviso. O que não gravaste, perdeste.

Android e iOS em traços largos

O Spotify continua a tocar em segundo plano porque declara um serviço em primeiro plano no Android e um modo de áudio no iOS. Sem isso, morria como qualquer outra app.

AppLifecycleState no Flutter

class _EcraPrevisaoState extends State<EcraPrevisao> {
  late final AppLifecycleListener _ciclo;

  @override
  void initState() {
    super.initState();
    _ciclo = AppLifecycleListener(
      onResume: _atualizarPrevisoes,          // voltou ao ecrã: os dados podem estar velhos
      onPause: _guardarRascunho,              // vai para segundo plano: grava já
      onStateChange: (estado) => debugPrint('ciclo de vida: $estado'),
    );
  }

  @override
  void dispose() {
    _ciclo.dispose();
    super.dispose();
  }

  void _atualizarPrevisoes() { /* pedir à API se passaram mais de 10 min */ }
  void _guardarRascunho() { /* shared_preferences, aula 16 */ }
}

Os estados são resumed, inactive, paused, hidden e detached. Para os testes: resumed é o momento de atualizar; paused é o último momento seguro para gravar.

Uma só thread de UI

• O código Dart da tua app corre num único isolate, com uma única thread. É a mesma que desenha a interface e responde ao toque.
• Um event loop tira tarefas de duas filas: microtasks (continuações de Futures: then, await) e eventos (toques, timers, respostas de rede, o pedido para desenhar o próximo frame). Esvazia sempre as microtasks antes de passar ao evento seguinte.
• await não bloqueia: suspende a função, devolve a thread ao loop, e a continuação entra na fila quando o valor chegar.
• Um cálculo pesado síncrono (decifrar um JSON de 5 MB, um ciclo de milhões de iterações, redimensionar uma foto) ocupa a thread até acabar. Enquanto isso nada se desenha e nenhum toque é tratado.

Para os testes: async/await não cria threads. Serve para esperar por rede e disco sem bloquear; não serve para acelerar cálculo.

Jank: 16 milissegundos por frame

• Um ecrã a 60 Hz mostra uma imagem nova a cada 16,6 ms; a 120 Hz (iPhone Pro, muitos Android recentes) a cada 8,3 ms.
• Nesse tempo o Flutter tem de correr build, layout, pintura e entregar à GPU. Se o teu código ocupar a thread por mais do que isso, o frame é saltado.
• O utilizador vê: scroll aos soluços, animação que salta, botão que só reage meio segundo depois. Chama-se jank e é o primeiro motivo de reviews de uma estrela.
• Bloqueios longos são piores: o Android mostra "A app não responde" (ANR) ao fim de 5 s; o iOS mata a app se o arranque demorar demais.
• Onde acontece na prática: parse de JSON grande no arranque, listas com widgets pesados, imagens em tamanho original.

Para os testes: 60 fps significa 16 ms de orçamento por frame; um frame perdido é jank.

Isolates: a resposta ao trabalho pesado

• Um isolate é uma thread com a sua própria memória. Dois isolates não partilham objetos; comunicam por mensagens, que são cópias.
• Isolate.run(() => jsonDecode(texto)) ou compute(parse, texto) corre a função noutro isolate e devolve o resultado como Future. A UI continua a 60 fps.
• Sem memória partilhada não há race conditions nem locks. Em troca, passar dados grandes custa tempo de cópia.
• Não podes tocar em widgets nem chamar plugins a partir de outro isolate.
• Casos reais: decifrar a resposta da API com mil previsões, comprimir uma foto antes de enviar, procurar numa lista de 50 000 itens.

Verificação do ambiente (10 min)

Antes da prática, cada um corre num terminal novo:

flutter doctor
flutter devices
git --version

Dart II no DartPad

Continuamos em dartpad.dev, sem Flutter. Seis blocos: Future, erros, paralelismo e timeouts, Stream, JSON, enums e extensões. No fim tens a classe Previsao que a app vai usar na segunda, já a ler JSON.

1. Escreve cada bloco à mão e corre. Lê os erros do compilador antes de perguntar.
2. Resolve o exercício antes de passar ao bloco seguinte.
3. Guarda o link de partilha do DartPad no fim: é o teu trabalho de hoje.

1. Future e async/await

import 'dart:math';

Future<double> lerTemperatura(String localidade) async {
  await Future.delayed(const Duration(seconds: 1));    // simula a espera pela rede
  return 15 + Random().nextInt(10) + Random().nextDouble();
}

void main() async {
  print('A pedir Ponta Delgada...');
  final t = await lerTemperatura('Ponta Delgada');      // espera aqui, sem bloquear
  print('Ponta Delgada: ${t.toStringAsFixed(1)} °C');

  final futuro = lerTemperatura('Horta');               // sem await: é só um valor futuro
  print('Já pedi Horta e continuei');
  futuro.then((t) => print('Horta: ${t.toStringAsFixed(1)} °C'));
  print('Fim do main (a Horta chega depois)');
}

1. Future: o que interessa

• Future<T> é a promessa de um valor T que ainda não existe. async marca a função; await espera pelo valor sem parar a thread.
• Uma função async devolve sempre um Future, mesmo que escrevas return 21.0.
• Só podes usar await dentro de uma função async. Se não fizeres await, o Future corre na mesma; só não esperas por ele.
• then é o que o await faz por baixo. Prefere await: lê-se de cima para baixo.

Para os testes: await suspende a função, não a thread.

2. Erros: try, on, catch, finally

class ApiException implements Exception {
  const ApiException(this.codigo, this.mensagem);
  final int codigo;
  final String mensagem;
  @override
  String toString() => 'ApiException($codigo): $mensagem';
}

Future<double> lerTemperatura(String localidade) async {
  await Future.delayed(const Duration(milliseconds: 500));
  if (localidade == 'Atlântida') throw const ApiException(404, 'localidade desconhecida');
  return 21.0;
}

void main() async {
  for (final l in ['Horta', 'Atlântida']) {
    try {
      print('$l: ${await lerTemperatura(l)} °C');
    } on ApiException catch (e) {
      print('A API recusou: ${e.mensagem} (${e.codigo})');   // erro esperado: trata-se
    } finally {
      print('--- pedido "$l" terminado');                      // corre sempre
    }
  }
}

2. Erros: o que interessa

• on Tipo catch (e) apanha só esse tipo; catch (e) apanha tudo. A ordem importa: do mais específico para o mais geral.
• finally corre sempre, com ou sem erro. É onde desligas o indicador de loading e fechas o que abriste.
• Uma exceção própria (implements Exception) com código e mensagem deixa a UI decidir: 404 mostra "não encontrado", 500 mostra "tenta mais tarde".
• Um await que falha lança a exceção no sítio do await. Sem try à volta, sobe até terminar a app com erro.

Para os testes: erros esperados (rede, API) tratam-se com on; erros de programação (ArgumentError, ! num null) devem falhar cedo, em desenvolvimento.

3. Pedidos em paralelo e timeouts

import 'dart:async';

void main() async {
  final localidades = ['Ponta Delgada', 'Angra do Heroísmo', 'Horta'];
  final cronometro = Stopwatch()..start();

  for (final l in localidades) {
    await lerTemperatura(l);                           // um de cada vez: 3 × 1 s
  }
  print('Em sequência: ${cronometro.elapsedMilliseconds} ms');

  cronometro.reset();
  final temps = await Future.wait(localidades.map(lerTemperatura));
  print('Em paralelo: ${cronometro.elapsedMilliseconds} ms → $temps');   // ~1 s, mesma ordem

  try {
    final t = await lerTemperatura('Flores').timeout(const Duration(milliseconds: 300));
    print('Flores: $t');
  } on TimeoutException {
    print('Rede lenta: mostra os dados antigos e tenta mais tarde');
  }
}

• Future.wait lança todos ao mesmo tempo e devolve uma lista pela ordem original. Se um falhar, o await lança.
• .timeout lança TimeoutException se o valor não chegar a tempo. Sem timeout, a app fica "a carregar" para sempre dentro de um túnel.

4. Stream: valores ao longo do tempo

import 'dart:async';

Stream<double> leituras() async* {
  for (var i = 0; i < 5; i++) {
    await Future.delayed(const Duration(milliseconds: 400));
    yield 18 + i * 0.5;                                // emite um valor e continua
  }
}

Stream<DateTime> relogio() =>
    Stream.periodic(const Duration(seconds: 1), (_) => DateTime.now());

void main() async {
  await for (final t in leituras()) {                  // consome até o stream fechar
    print('Leitura: $t °C');
  }

  final subscricao = relogio().listen(
    (agora) => print('${agora.hour}:${agora.minute}:${agora.second}'),
  );
  await Future.delayed(const Duration(seconds: 3));
  await subscricao.cancel();                           // um stream infinito tem de ser cancelado
  print('Fim');
}

• Um Stream é uma sequência de valores no tempo: leituras de um sensor, posição GPS, mensagens de um WebSocket, o relógio do ecrã.
• async* e yield criam; await for consome; listen devolve uma subscrição que tens de cancelar em dispose (aula 8).

5. JSON (1 de 2): o modelo

import 'dart:convert';

class Previsao {
  const Previsao({required this.localidade, required this.dia, required this.tMin, required this.tMax});

  final String localidade;
  final DateTime dia;
  final double tMin;
  final double tMax;

  factory Previsao.fromJson(Map<String, dynamic> json) => Previsao(
        localidade: json['localidade'] as String,
        dia: DateTime.parse(json['dia'] as String),
        tMin: (json['tMin'] as num).toDouble(),        // a API pode mandar 17 ou 17.0
        tMax: (json['tMax'] as num).toDouble(),
      );

  Map<String, dynamic> toJson() => {
        'localidade': localidade,
        'dia': dia.toIso8601String(),
        'tMin': tMin,
        'tMax': tMax,
      };
}

5. JSON (2 de 2): decifrar e serializar

const corpo = '''
[
  {"localidade": "Horta", "dia": "2026-09-23", "tMin": 17, "tMax": 22.5},
  {"localidade": "Horta", "dia": "2026-09-24", "tMin": 16, "tMax": 21}
]''';

void main() {
  final bruto = jsonDecode(corpo) as List<dynamic>;        // ainda não sabe o que é
  final previsoes = bruto
      .map((e) => Previsao.fromJson(e as Map<String, dynamic>))
      .toList();

  print(previsoes.length);                                     // 2
  print(previsoes.first.tMax);                                 // 22.5
  print(previsoes.map((p) => p.dia.day).toList());             // [23, 24]

  final texto = jsonEncode(previsoes.map((p) => p.toJson()).toList());
  print(texto);                                                // pronto para enviar ou gravar
}

Pipeline: String (corpo da resposta) → jsonDecode → Map / List → fromJson → Previsao → List<Previsao> → widgets

5. JSON: o que interessa

• jsonDecode devolve dynamic: uma Map<String, dynamic> para objetos, uma List<dynamic> para listas. Fazes o cast e depois constróis os teus objetos.
• fromJson é um factory: recebe o mapa e devolve uma instância. toJson faz o caminho inverso. Este par vai existir em todos os modelos do projeto.
• Números: o JSON não distingue 17 de 17.0; em Dart o primeiro é int. (x as num).toDouble() evita um crash.
• Se um campo faltar, json['tMax'] as num lança TypeError. Validar isto é o trabalho de casa.

Para os testes: em Dart o JSON é decifrado para Map e List genéricos; a conversão para classes é código teu (ou gerado com json_serializable).

6. Enums com valores e extension methods

enum TipoTempo {
  sol('☀️', 'Céu limpo'),
  nublado('☁️', 'Nublado'),
  chuva('🌧️', 'Chuva'),
  trovoada('⛈️', 'Trovoada');

  const TipoTempo(this.icone, this.descricao);
  final String icone;
  final String descricao;

  static TipoTempo fromApi(String codigo) =>
      values.firstWhere((t) => t.name == codigo, orElse: () => nublado);
}

extension Temperatura on double {
  String get celsius => '${toStringAsFixed(1)} °C';
  double get fahrenheit => this * 9 / 5 + 32;
}

void main() {
  final t = TipoTempo.fromApi('chuva');
  print('${t.icone} ${t.descricao}');   // 🌧️ Chuva
  print(21.456.celsius);                // 21.5 °C
  print(21.0.fahrenheit);               // 69.8
}

6. Enums e extensões: o que interessa

• Um enum pode ter campos, construtor const, getters e métodos estáticos. values é a lista de todos; name é o identificador como texto.
• firstWhere com orElse transforma a string da API num valor do enum sem falhar quando aparece um valor novo.
• extension X on Tipo acrescenta métodos a tipos que não são teus (double, DateTime, String). Precisa de estar importada no ficheiro onde a usas.
• Em Flutter vais ver extensões em BuildContext (context.theme) e em num em muitos packages do pub.dev.

Para os testes: um enum em Dart 3 é uma classe com um número fixo de instâncias; pode ter campos e métodos, mas não pode ser estendido.

Até segunda