Skip to content

6. Processamento assíncrono e estado compartilhado

6.1. Exemplo 19: Future, Stream e timers

Muitas coisas acontecem “mais tarde”: ticks de timer, teclas digitadas, a resposta de um servidor. O [Dart] tem dois tipos para isso, no núcleo da linguagem:

  • [Future<T>]: UM valor, mais tarde (a resposta de um servidor, uma escolha feita em uma janela);
  • [Stream<T>]: uma SEQUÊNCIA de valores ao longo do tempo (ticks, mensagens, posições de GPS...).

O [Flutter] tem um widget para exibir cada um deles, reconstruindo-o quando um valor chega: [FutureBuilder] e [StreamBuilder]. E para o que deve acontecer após um atraso: [Timer].

// =========================================================================
// lib/ex19_asynchronous/main.dart - Future, Stream, timers
// -------------------------------------------------------------------------
// Muitas coisas acontecem "depois": os ticks de um timer, as
// teclas digitadas, a resposta de um servidor. O Dart tem dois tipos para
// isso, no coração da linguagem:
//   - Future<T>: UM valor, depois (a resposta de um servidor);
//   - Stream<T>: uma SEQUÊNCIA de valores, ao longo do tempo (ticks,
//     mensagens...).
// O Flutter tem um widget para exibir cada um, reconstruindo-o quando um
// valor chega: FutureBuilder e StreamBuilder.
// E para o que deve acontecer após um atraso: Timer (dart:async).
// =========================================================================

import 'dart:async';
import 'dart:math';

import 'package:flutter/material.dart';

const doctors = ['Marie PELISSIER', 'Paul TATOU', 'Sophie DUPONT', 'Jacques DURAND', 'Martine PELLETIER'];
final _random = Random();

// um "servidor" simulado: a resposta (um Future) chega após um atraso aleatório
Future<List<String>> search(String text) async {
  await Future<void>.delayed(Duration(milliseconds: 200 + _random.nextInt(600)));
  return doctors.where((m) => m.toLowerCase().contains(text)).toList();
}

// 1. um Stream produzido por uma função "async*": cada yield ENVIA um
// valor a quem escuta o Stream
Stream<int> countdown(int start) async* {
  for (var remaining = start; remaining >= 0; remaining--) {
    yield remaining;
    if (remaining > 0) await Future<void>.delayed(const Duration(seconds: 1));
  }
}

String currentTime() => DateTime.now().toString().substring(11, 19);

void main() {
  runApp(
    MaterialApp(
      debugShowCheckedModeBanner: false,
      theme: ThemeData(colorSchemeSeed: Colors.indigo),
      home: const AsynchronousPage(),
    ),
  );
}

class AsynchronousPage extends StatefulWidget {
  const AsynchronousPage({super.key});

  @override
  State<AsynchronousPage> createState() => _AsynchronousPageState();
}

class _AsynchronousPageState extends State<AsynchronousPage> {
  final List<String> _log = [];
  // o Stream e o Future são criados UMA vez (e não a cada build:
  // cada chamada de build reiniciaria a contagem regressiva!)
  final Stream<int> _countdown = countdown(20);
  // 3. um Future que termina após um segundo
  final Future<String> _message = Future.delayed(const Duration(seconds: 1), () => 'three (one second later)');

  // 2. a pesquisa enquanto se digita
  Timer? _debounce;
  int _requestNumber = 0; // o número da ÚLTIMA pesquisa iniciada
  List<String> _results = [];

  void _trace(String message) => setState(() => _log.add('${currentTime()} $message'));

  // chamado a cada tecla digitada
  void _onInput(String text) {
    // o DEBOUNCE: cada tecla cancela o timer da tecla anterior;
    // a pesquisa só começa após 400 ms sem nenhuma tecla
    _debounce?.cancel();
    _debounce = Timer(const Duration(milliseconds: 400), () => _launch(text.trim().toLowerCase()));
  }

  Future<void> _launch(String text) async {
    // menos de duas letras: nenhuma pesquisa, nenhum resultado
    if (text.length < 2) {
      _requestNumber++; // uma resposta ainda esperada será ignorada
      setState(() => _results = []);
      return;
    }
    // "obsoleta" (stale): uma resposta que chega DEPOIS que outra pesquisa foi
    // iniciada deve ser ignorada (senão a resposta lenta de uma pesquisa
    // antiga sobrescreveria a da nova)
    final number = ++_requestNumber;
    _trace('search sent: "$text"');
    final found = await search(text);
    if (!mounted) return;
    if (number != _requestNumber) {
      _trace('response ignored (stale): "$text"');
      return;
    }
    setState(() => _results = found);
  }

  @override
  void dispose() {
    _debounce?.cancel();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    final titleStyle = Theme.of(context).textTheme.titleSmall;
    return Scaffold(
      appBar: AppBar(title: const Text('Example 19 - asynchrony')),
      body: ListView(
        padding: const EdgeInsets.all(16),
        children: [
          Card(
            child: Padding(
              padding: const EdgeInsets.all(12),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text('A countdown (a Stream and StreamBuilder)', style: titleStyle),
                  // StreamBuilder: reconstrói seu conteúdo a cada valor do Stream;
                  // snapshot.data: o último valor recebido (null antes do primeiro)
                  StreamBuilder<int>(
                    stream: _countdown,
                    builder: (context, snapshot) =>
                        Text(snapshot.hasData ? '${snapshot.data}' : '...', style: Theme.of(context).textTheme.displaySmall),
                  ),
                ],
              ),
            ),
          ),
          Card(
            child: Padding(
              padding: const EdgeInsets.all(12),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text('A search as you type (debounce, stale responses)', style: titleStyle),
                  TextField(
                    decoration: const InputDecoration(hintText: 'at least two letters: pel, dur...'),
                    onChanged: _onInput,
                  ),
                  for (final r in _results) Text('• $r'),
                  if (_results.isEmpty) const Text('no result', style: TextStyle(color: Colors.grey)),
                ],
              ),
            ),
          ),
          Card(
            child: Padding(
              padding: const EdgeInsets.all(12),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text('Waiting for a Future (FutureBuilder)', style: titleStyle),
                  // enquanto o Future não terminar: o conteúdo de espera
                  FutureBuilder<String>(
                    future: _message,
                    builder: (context, snapshot) => switch (snapshot.connectionState) {
                      ConnectionState.done => Text('received: ${snapshot.data}'),
                      _ => const Text('waiting...', style: TextStyle(color: Colors.grey)),
                    },
                  ),
                ],
              ),
            ),
          ),
          Text('Log', style: titleStyle),
          for (final (i, line) in _log.indexed) Text('${i + 1}. $line', style: const TextStyle(fontSize: 12)),
        ],
      ),
    );
  }
}
  • linhas 24–26: um “servidor” simulado: uma função [async], cuja resposta (um [Future]) chega após um atraso aleatório. [await Future<void>.delayed(...)] espera por esse atraso sem bloquear o aplicativo;
  • linhas 31–34: um [Stream] gerado por uma função [async*] (com asterisco): um gerador assíncrono. Cada [yield] envia um valor a quem está ouvindo o [Stream]; entre os valores, a função espera um segundo;
  • linhas 61–63: o [Stream] e o [Future] são criados UMA ÚNICA vez, em campos do objeto [State], e não em [build]: cada reconstrução reiniciaria a contagem regressiva! Este é o erro mais comum com [FutureBuilder] e [StreamBuilder];
  • linhas 66–68: o estado da pesquisa enquanto o usuário digita: um timer, o número da última pesquisa iniciada e os resultados;
  • linhas 73–77: debouncing: o programa espera o usuário fazer uma pausa antes de consultar o servidor, em vez de enviar uma requisição a cada tecla digitada. Cada tecla digitada zera o timer da tecla anterior ([cancel()]) e inicia um novo: a pesquisa só é disparada após 400 milissegundos sem nenhuma tecla;
  • Linhas 80–98: a pesquisa. Uma resposta “desatualizada” (que chega DEPOIS de outra pesquisa ter sido lançada) deve ser ignorada: caso contrário, a resposta lenta de uma pesquisa antiga sobrescreveria a da nova. Cada pesquisa recebe um número ([++_requestNumber]); quando sua resposta chega, se esse não for mais o número da pesquisa mais recente, ela é ignorada. [if (!mounted) return;]: a tela pode ter desaparecido durante a espera;
  • linhas 102–104: o timer é interrompido se a tela desaparecer;
  • linhas 124–127: [StreamBuilder] escuta o [Stream] e reconstrói seu conteúdo a cada novo valor. [builder] recebe um snapshot ([snapshot], um [AsyncSnapshot]): [snapshot.hasData], [snapshot.data] (o último valor recebido), [snapshot.hasError], [snapshot.connectionState]. Quando o widget desaparece, [StreamBuilder] cancela a inscrição por conta própria;
  • linhas 158–162: [FutureBuilder] espera o [Future]: até que ele termine, o conteúdo provisório; depois, seu valor. [switch] sobre [snapshot.connectionState] escolhe um ou outro.

Digitamos rapidamente “p”, “pe”, “pel”: apenas uma pesquisa é enviada. Depois “du”, seguido de “dup” antes da resposta: a resposta a “du” chega tarde demais e é ignorada se “dup” já tiver recebido sua resposta:

Em [JavaScript], a mesma coisa é escrita com promises e timers; o [Angular] acrescenta os "observables" do [RxJS]. No [Dart], [Future] e [Stream] estão na biblioteca básica, e [async], [await], [async*], [yield] e [await for] estão na linguagem: é por isso que o [Flutter] não exige uma biblioteca para operações assíncronas.

6.2. Exemplo 20: um estado compartilhado

A mesma pergunta das lições anteriores: quais são os “escopos” dos dados de um aplicativo?

  • O estado local de um widget desaparece quando o widget é removido;
  • o estado de um “store” é compartilhado por todos os widgets e sobrevive à sua remoção… mas não ao encerramento do aplicativo;
  • o estado guardado no dispositivo sobrevive ao encerramento do aplicativo.

6.2.1. O carrinho de compras

// =========================================================================
// lib/ex20_shared_state/stores/cart.dart - um ESTADO COMPARTILHADO, com provider
// -------------------------------------------------------------------------
// Um "store" é um estado que vive FORA das telas, em uma ÚNICA
// instância, compartilhada por todos os que o leem. O exemplo 14 fez isso
// à mão (InheritedNotifier); o pacote provider, o mais usado
// com o Flutter (e recomendado pela sua documentação), faz a mesma coisa
// em uma linha:
//
//     ChangeNotifierProvider(create: (_) => Cart(), child: ...)
//
// O store é um ChangeNotifier comum. Organização usual:
//   - o ESTADO: dados PRIVADOS (_items);
//   - as AÇÕES: métodos, os únicos a modificar o estado, que terminam
//     com notifyListeners();
//   - os valores calculados: getters.
// Um widget o acessa por meio do seu context:
//   - context.watch<Cart>()  : ler E se inscrever (reconstruído a cada alteração);
//   - context.read<Cart>()   : ler sem se inscrever (para chamar uma ação);
//   - context.select<Cart, int>((p) => p.count) : inscrever-se em UM valor:
//     reconstruído somente se ESTE valor mudar.
// O store vive enquanto seu provider viver: ele sobrevive à remoção de uma
// tela... mas não à parada do aplicativo.
// =========================================================================

import 'package:flutter/foundation.dart';

typedef Item = ({String label, double price});

class Cart extends ChangeNotifier {
  final List<Item> _items = [];

  // uma visão NÃO MODIFICÁVEL da lista: somente as ações a alteram
  List<Item> get items => List.unmodifiable(_items);
  int get count => _items.length;
  double get total => _items.fold(0, (s, a) => s + a.price);

  void add(Item item) {
    _items.add(item);
    notifyListeners();
  }

  void clear() {
    _items.clear();
    notifyListeners();
  }
}

Um store é um estado que abrange várias telas, existindo como uma única instância compartilhada por todos que o acessam. O exemplo 14 implementou isso manualmente. O pacote [provider], o mais usado junto com o [Flutter] (e o recomendado em sua documentação), faz o mesmo em uma única linha: [ChangeNotifierProvider(create: (_) => Cart(), child: ...)].

  • Linha 31: o estado: dados privados;
  • linhas 34–36: valores calculados: getters. [List.unmodifiable]: uma visão somente leitura da lista; apenas as ações podem modificá-la;
  • linhas 38–45: as ações: métodos — os únicos que modificam o estado — que terminam com [notifyListeners()].

6.2.2. Preferências

// =========================================================================
// lib/ex20_shared_state/stores/preferences.dart - um estado que sobrevive à parada
// -------------------------------------------------------------------------
// Para que um dado sobreviva à parada do aplicativo, ele deve ser guardado
// NO DISPOSITIVO. O pacote shared_preferences oferece um pequeno dicionário
// chave -> valor (bool, int, double, String), específico do aplicativo e
// mantido no dispositivo (na web: no localStorage do navegador).
//   - na inicialização, os valores guardados são lidos (main.dart);
//   - a cada alteração, eles são escritos de novo.
// NUNCA guarde dados sensíveis ali (senha, token): eles são
// escritos em texto puro.
// =========================================================================

import 'package:flutter/foundation.dart';
import 'package:shared_preferences/shared_preferences.dart';

class Preferences extends ChangeNotifier {
  static const _darkKey = 'example20.dark';
  static const _sizeKey = 'example20.size';

  final SharedPreferences _storage;
  bool _dark;
  double _size; // tamanho do texto

  // o estado inicial: o que o dispositivo guardou, senão os valores padrão
  Preferences(this._storage)
    : _dark = _storage.getBool(_darkKey) ?? false,
      _size = _storage.getDouble(_sizeKey) ?? 16;

  bool get dark => _dark;
  double get size => _size;

  // um parâmetro nomeado opcional por preferência: só o que é fornecido muda
  void update({bool? dark, double? size}) {
    if (dark != null) {
      _dark = dark;
      _storage.setBool(_darkKey, dark); // escrita no dispositivo
    }
    if (size != null) {
      _size = size;
      _storage.setDouble(_sizeKey, size);
    }
    notifyListeners();
  }
}

Para que os dados sobrevivam ao encerramento do aplicativo, eles devem ser guardados no dispositivo. O pacote [shared_preferences] oferece um pequeno dicionário chave->valor ([bool], [int], [double], [String]), específico do aplicativo e armazenado no dispositivo (na web: no [localStorage] do navegador).

  • Linha 21: os dados de armazenamento, recebidos na criação;
  • linhas 26–28: o estado inicial: o que o dispositivo armazenou ou, caso contrário, valores padrão. Os campos são inicializados pela “lista de inicialização” do construtor (depois dos dois-pontos), antes do corpo;
  • Linhas 34–43: uma única ação, com parâmetros nomeados opcionais: apenas os valores fornecidos são alterados, e eles são imediatamente gravados no dispositivo ([setBool], [setDouble]).

NUNCA guarde dados sensíveis (senhas, tokens) ali: esses dados são gravados em texto simples. Para essa finalidade, existe o pacote [flutter_secure_storage], que usa o cofre do sistema ([Keystore] do [Android], [Keychain] do [iOS]).

6.2.3. Os widgets

// lib/ex20_shared_state/components/shop.dart - ACRESCENTA ao carrinho compartilhado
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';

import '../stores/cart.dart';

const products = <Item>[(label: 'Consultation', price: 30), (label: 'Vaccine', price: 12.5)];

class Shop extends StatelessWidget {
  const Shop({super.key});

  @override
  Widget build(BuildContext context) {
    // read: apenas CHAMAMOS uma ação; Shop não é
    // reconstruído quando o carrinho muda
    final cart = context.read<Cart>();
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(12),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text('Shop', style: Theme.of(context).textTheme.titleSmall),
            for (final p in products)
              TextButton.icon(
                icon: const Icon(Icons.add),
                label: Text('${p.label} (${p.price} €)'),
                onPressed: () => cart.add(p),
              ),
          ],
        ),
      ),
    );
  }
}
  • Linha 16: [context.read<Cart>()] lê o carrinho de compras fornecido acima, SEM se inscrever: o store simplesmente chama uma ação; ele não precisa ser reconstruído quando o carrinho muda.
// lib/ex20_shared_state/components/cart_summary.dart - LÊ o mesmo carrinho
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';

import '../stores/cart.dart';

class CartSummary extends StatelessWidget {
  const CartSummary({super.key});

  @override
  Widget build(BuildContext context) {
    // select: reconstrói SOMENTE se a quantidade ou o total mudar
    final count = context.select<Cart, int>((p) => p.count);
    final total = context.select<Cart, double>((p) => p.total);
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(12),
        child: Row(
          children: [
            const Icon(Icons.shopping_cart),
            const SizedBox(width: 8),
            Expanded(child: Text('$count item(s), $total €')),
            TextButton(
              onPressed: count == 0 ? null : () => context.read<Cart>().clear(),
              child: const Text('Clear'),
            ),
          ],
        ),
      ),
    );
  }
}
  • Linhas 13–14: [context.select] lê UM valor do carrinho de compras e inscreve o widget NESSE valor: ele só é reconstruído se esse valor mudar. [context.watch<Cart>()] leria e se inscreveria em todo o carrinho de compras.
// lib/ex20_shared_state/components/local_counter.dart - um estado LOCAL, que desaparece com o widget
import 'package:flutter/material.dart';

class LocalCounter extends StatefulWidget {
  final String title;

  const LocalCounter({super.key, required this.title});

  @override
  State<LocalCounter> createState() => _LocalCounterState();
}

class _LocalCounterState extends State<LocalCounter> {
  int _clicks = 0;

  @override
  Widget build(BuildContext context) {
    return Card(
      child: ListTile(
        title: Text(widget.title),
        trailing: OutlinedButton(onPressed: () => setState(() => _clicks++), child: Text('$_clicks click(s)')),
      ),
    );
  }
}

Um estado local que desaparece junto com o widget.

6.2.4. O aplicativo

// =========================================================================
// lib/ex20_shared_state/main.dart - três "escopos" de dados
// -------------------------------------------------------------------------
//   - o estado LOCAL de um widget (LocalCounter) desaparece com ele;
//   - o estado de um STORE (o carrinho) é compartilhado por todos os widgets
//     e sobrevive à sua remoção - mas não à parada do aplicativo;
//   - o estado guardado no dispositivo (as preferências) sobrevive à parada.
// E Visibility(maintainState: true): o conteúdo fica OCULTO, mas não
// removido; seu estado local é mantido.
// Desmarque e marque de novo "mostrar a área", depois pare e reinicie
// o aplicativo: compare.
// =========================================================================

import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';

import 'components/shop.dart';
import 'components/local_counter.dart';
import 'components/cart_summary.dart';
import 'stores/cart.dart';
import 'stores/preferences.dart';

Future<void> main() async {
  // indispensável antes de usar um "plugin" (código específico do Android, iOS,
  // web...) como shared_preferences, ANTES de runApp
  WidgetsFlutterBinding.ensureInitialized();
  final storage = await SharedPreferences.getInstance();
  runApp(
    // MultiProvider: vários providers, aninhados uns nos outros,
    // acima de todo o aplicativo
    MultiProvider(
      providers: [
        ChangeNotifierProvider(create: (_) => Cart()),
        ChangeNotifierProvider(create: (_) => Preferences(storage)),
      ],
      child: const Application(),
    ),
  );
}

class Application extends StatelessWidget {
  const Application({super.key});

  @override
  Widget build(BuildContext context) {
    // watch: o aplicativo é reconstruído quando as preferências mudam
    final preferences = context.watch<Preferences>();
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      theme: ThemeData(colorSchemeSeed: Colors.indigo),
      // o tema escuro e a escolha entre os dois
      darkTheme: ThemeData(colorSchemeSeed: Colors.indigo, brightness: Brightness.dark),
      themeMode: preferences.dark ? ThemeMode.dark : ThemeMode.light,
      // builder: envolve TODAS as telas; aqui, o tamanho do texto
      builder: (context, child) => MediaQuery(
        data: MediaQuery.of(context).copyWith(textScaler: TextScaler.linear(preferences.size / 16)),
        child: child!,
      ),
      home: const SharedStatePage(),
    );
  }
}

class SharedStatePage extends StatefulWidget {
  const SharedStatePage({super.key});

  @override
  State<SharedStatePage> createState() => _SharedStatePageState();
}

class _SharedStatePageState extends State<SharedStatePage> {
  bool _areaVisible = true;

  @override
  Widget build(BuildContext context) {
    final preferences = context.watch<Preferences>();
    return Scaffold(
      appBar: AppBar(title: const Text('Example 20 - a shared state')),
      body: ListView(
        padding: const EdgeInsets.all(12),
        children: [
          SwitchListTile(
            title: const Text('dark theme'),
            value: preferences.dark,
            onChanged: (v) => preferences.update(dark: v),
          ),
          ListTile(
            title: Text('text size: ${preferences.size.round()}'),
            subtitle: Slider(
              value: preferences.size,
              min: 12,
              max: 22,
              divisions: 10,
              onChanged: (v) => preferences.update(size: v),
            ),
          ),
          CheckboxListTile(
            title: const Text('show the area'),
            value: _areaVisible,
            onChanged: (v) => setState(() => _areaVisible = v!),
          ),
          // removidos: estes widgets desaparecem, com seu estado local
          if (_areaVisible) ...[const Shop(), const CartSummary(), const LocalCounter(title: 'Local state')],
          // ocultos: o widget permanece na memória, seu estado é mantido
          Visibility(
            visible: _areaVisible,
            maintainState: true,
            child: const LocalCounter(title: 'Local state, in a Visibility'),
          ),
          const Padding(
            padding: EdgeInsets.symmetric(vertical: 8),
            child: Text('Outside the area, a second summary of the SAME cart (it stays there when the area disappears):'),
          ),
          const CartSummary(),
        ],
      ),
    );
  }
}
  • Linhas 27–28: [shared_preferences] é um "plugin": ele usa código específico de cada plataforma ([Android], web...). Para usá-lo ANTES de [runApp], é preciso primeiro inicializar o [Flutter] ([ensureInitialized]). A leitura do armazenamento é assíncrona: [main] espera que ela termine;
  • linhas 32–35: [MultiProvider] coloca vários providers, um dentro do outro, no topo de todo o aplicativo. [ChangeNotifierProvider] cria o [ChangeNotifier] ([create]), fornece-o aos seus descendentes, reconstrói os que se inscrevem nele quando ele muda e o libera quando desaparece;
  • linha 48: o aplicativo lê as preferências e se inscreve nelas; ele é reconstruído quando elas mudam;
  • linhas 53–54: dois temas, claro e escuro, e a opção de escolher entre eles ([themeMode]);
  • linhas 56–58: o [builder] do [MaterialApp] envolve TODAS as telas. Aqui, o tamanho do texto de todo o aplicativo é alterado: [MediaQuery] descreve a tela e os ajustes do usuário (inclusive [textScaler], o fator de ampliação do texto, que também pode ser ajustado nas configurações de acessibilidade do celular);
  • linha 104: removida; a área desaparece, junto com o estado local de seus widgets;
  • Linhas 106–109: [Visibility] com [maintainState: true] OCULTA seu filho sem removê-lo: seu estado é preservado. (É o que [<Activity mode="hidden">] faz no curso de [React].)

Adicionamos dois itens e clicamos uma vez em cada contador local (à esquerda); removemos a área e passamos para o modo escuro (no meio); restauramos a área (à direita):

O carrinho de compras sobreviveu à remoção da seção (como mostra o segundo resumo); o contador removido voltou a zero; o contador oculto manteve seu valor. Pare o aplicativo e reinicie-o: o tema escuro e o tamanho do texto são preservados, e o carrinho de compras está vazio.

Por que [provider]? Há muitas bibliotecas de gerenciamento de estado para o [Flutter] ([Riverpod], [Bloc], [GetX], [MobX]...). [provider] é o mais simples: é apenas uma forma conveniente de escrever o [InheritedWidget] do exemplo 14, com base em o [ChangeNotifier] do [Flutter]. É o usado no guia de arquitetura da documentação do [Flutter] e o que será usado no estudo de caso.