Skip to content

6. Operações assíncronas e estado compartilhado

6.1. Exemplo 19: Promises, Observables e timers

Muitas coisas acontecem “mais tarde”: ticks de timer, teclas digitadas e respostas do servidor. Uma aplicação [Ionic] tem dois tipos para isso:

  • [Promise<T>], a do [JavaScript]: UM valor, mais tarde (uma resposta do servidor, uma seleção feita em uma janela). As palavras-chave [async] e [await] permitem aguardá-lo sem bloquear a aplicação. É o [Future] do [Dart];
  • [Observable<T>], que vem da biblioteca [RxJS], fornecida com o [Angular]: uma SEQUÊNCIA de valores ao longo do tempo (ticks, teclas digitadas, mensagens...), que são transformados por operadores ([map], [take], [debounceTime], [switchMap]...). É o [Stream] derivado do [Dart]. [JavaScript] também tem suas contrapartes assíncronas: os geradores assíncronos ([async function*]), que são os equivalentes das funções [async*] do [Dart].

Para exibi-los, o [Angular] oferece três ferramentas, equivalentes ao [FutureBuilder] e ao [StreamBuilder]: o pipe [async] (um [Observable] lido a partir do template), [toSignal()] (um [Observable] convertido em signal) e [resource()] (uma [Promise] convertida em signals). E para o que deve acontecer após um atraso: [setTimeout], ou os timers do [RxJS] ([timer], [interval]).

6.1.1. A página

// =========================================================================
// src/app/ex19-asynchronous/ex19.page.ts - promises, observables, timers
// -------------------------------------------------------------------------
// Muitas coisas acontecem "depois": os ticks de um timer, as
// teclas digitadas, a resposta de um servidor. Dois tipos estão disponíveis:
//   - Promise (JavaScript): UM valor, depois (a resposta de um
//     servidor); async / await para esperá-lo;
//   - Observable (biblioteca RxJS, distribuída com o Angular): uma SEQUÊNCIA de
//     valores, ao longo do tempo (ticks, teclas digitadas...), que transformamos
//     com "operadores" (map, take, debounceTime, switchMap...).
// Para exibi-los, o Angular oferece o pipe async (um Observable no
// template), toSignal() (um Observable transformado em signal) e resource() (uma
// Promise transformada em signal).
// =========================================================================

import { AsyncPipe } from '@angular/common';
import { Component, resource, signal } from '@angular/core';
import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
import {
  IonBackButton, IonButtons, IonCard, IonCardContent, IonCardHeader, IonCardSubtitle, IonContent, IonHeader, IonInput,
  IonNote, IonTitle, IonToolbar,
} from '@ionic/angular';
import { debounceTime, finalize, from, map, Observable, of, Subject, switchMap, take, tap, timer } from 'rxjs';

const doctors = ['Marie PELISSIER', 'Paul TATOU', 'Sophie DUPONT', 'Jacques DURAND', 'Martine PELLETIER'];

// um timer na forma de uma Promise: termina após ms milissegundos
function wait(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// um "servidor" simulado: a resposta (uma Promise) chega após um atraso aleatório
async function search(text: string): Promise<string[]> {
  await wait(200 + Math.floor(Math.random() * 600));
  return doctors.filter((m) => m.toLowerCase().includes(text));
}

// 1a. um GERADOR ASSÍNCRONO (async function*, com um asterisco): cada
// yield ENVIA um valor a quem itera sobre ele (for await...of)
async function* countdown(start: number): AsyncGenerator<number> {
  for (let remaining = start; remaining >= 0; remaining--) {
    yield remaining;
    if (remaining > 0) await wait(1000);
  }
}

// "15:30:45"
const currentTime = () => new Date().toTimeString().substring(0, 8);

@Component({
  selector: 'app-ex19',
  imports: [
    AsyncPipe, IonHeader, IonToolbar, IonButtons, IonBackButton, IonTitle, IonContent, IonCard, IonCardHeader,
    IonCardSubtitle, IonCardContent, IonInput, IonNote,
  ],
  templateUrl: './ex19.page.html',
  styles: `
    .number { font-size: 2em; color: var(--ion-text-color); }
    .log { font-size: 12px; }
  `,
})
export class Ex19Page {
  readonly log = signal<string[]>([]);

  // 1a. o gerador, transformado em Observable por from(); o template
  // o exibe com o pipe async. Criado UMA VEZ, em um campo
  readonly countdown$: Observable<number> = from(countdown(20));

  // 1b. a mesma contagem regressiva, com operadores RxJS: timer(0, 1000)
  // emite 0, 1, 2... a cada segundo; take(21) para após 21 valores;
  // map os transforma (0 -> 20, 1 -> 19...). toSignal: um signal cujo valor é
  // o último valor recebido (undefined antes do primeiro)
  readonly countdown = toSignal(timer(0, 1000).pipe(take(21), map((i) => 20 - i)));

  // 3. uma Promise que termina após um segundo, seguida de resource():
  // um objeto com signals (isLoading(), hasValue(), value(), error()...)
  readonly message = resource({
    loader: async () => {
      await wait(1000);
      return 'three (one second later)';
    },
  });

  // 2. a busca enquanto se digita: um Subject é um Observable no
  // qual EMPURRAMOS os valores nós mesmos (next): aqui, cada tecla digitada
  private readonly keystrokes = new Subject<string>();
  readonly results = signal<string[]>([]);

  constructor() {
    this.keystrokes
      .pipe(
        // o DEBOUNCE: um valor só é repassado após 400 ms sem
        // uma nova tecla; teclas muito próximas são esquecidas
        debounceTime(400),
        map((text) => text.trim().toLowerCase()),
        // switchMap: cada texto inicia uma busca (um Observable); uma
        // NOVA busca ABANDONA a anterior, cuja resposta nunca
        // será repassada: nenhuma resposta "obsoleta"
        switchMap((text) => this.launch(text)),
        // a assinatura termina quando a página é destruída
        takeUntilDestroyed(),
      )
      .subscribe((found) => this.results.set(found));
  }

  private trace(message: string): void {
    this.log.update((lines) => [...lines, `${currentTime()} ${message}`]);
  }

  // chamado a cada tecla digitada
  input(text: string | null | undefined): void {
    this.keystrokes.next(text ?? '');
  }

  private launch(text: string): Observable<string[]> {
    // menos de duas letras: nenhuma busca, nenhum resultado
    if (text.length < 2) {
      return of([]);
    }
    this.trace(`search sent: "${text}"`);
    let received = false;
    // from(Promise): um Observable que emite o valor da Promise e depois é concluído
    return from(search(text)).pipe(
      tap(() => (received = true)),
      // finalize: chamado quando o Observable é concluído OU quando cancelamos a assinatura
      // (é o que o switchMap faz quando chega uma nova busca)
      finalize(() => {
        if (!received) this.trace(`response ignored (stale): "${text}"`);
      }),
    );
  }
}
<!-- ======================================================================
     ex19.page.html - promises, observables e timers
     ====================================================================== -->

<ion-header>
  <ion-toolbar color="primary">
    <ion-buttons slot="start">
      <ion-back-button defaultHref="/" />
    </ion-buttons>
    <ion-title>Example 19 - asynchrony</ion-title>
  </ion-toolbar>
</ion-header>

<ion-content class="ion-padding">
  <ion-card>
    <ion-card-header>
      <ion-card-subtitle>Two countdowns (Observables)</ion-card-subtitle>
    </ion-card-header>
    <ion-card-content>
      <!-- o pipe async se inscreve no Observable, exibe cada novo
           valor e cancela a inscrição quando a página desaparece; ele é null
           antes do primeiro valor. @let: uma variável de template -->
      @let n = countdown$ | async;
      <p>async function* and async pipe: <span class="number">{{ n ?? '...' }}</span></p>
      <!-- o signal: undefined antes do primeiro valor -->
      <p>RxJS and toSignal(): <span class="number">{{ countdown() ?? '...' }}</span></p>
    </ion-card-content>
  </ion-card>

  <ion-card>
    <ion-card-header>
      <ion-card-subtitle>A search as you type (debounce, stale responses)</ion-card-subtitle>
    </ion-card-header>
    <ion-card-content>
      <!-- (ionInput): a cada tecla digitada -->
      <ion-input placeholder="at least two letters: pel, dur..." (ionInput)="input($event.detail.value)" />
      @for (r of results(); track r) {
        <p>• {{ r }}</p>
      } @empty {
        <ion-note>no result</ion-note>
      }
    </ion-card-content>
  </ion-card>

  <ion-card>
    <ion-card-header>
      <ion-card-subtitle>Waiting for a Promise (resource)</ion-card-subtitle>
    </ion-card-header>
    <ion-card-content>
      <!-- enquanto a Promise não terminar: o conteúdo de espera -->
      @if (message.hasValue()) {
        <p>received: {{ message.value() }}</p>
      } @else {
        <ion-note>waiting...</ion-note>
      }
    </ion-card-content>
  </ion-card>

  <h6>Log</h6>
  @for (line of log(); track $index) {
    <div class="log">{{ $index + 1 }}. {{ line }}</div>
  }
</ion-content>

Ferramentas:

  • linhas 28–30 (.ts): um timer na forma de [Promise]. [new Promise(...)] recebe uma função que inicia a tarefa e chamará [resolve] quando ela terminar; aqui, [setTimeout] a chama após [ms] milissegundos. [await wait(1000)] espera, portanto, um segundo, sem bloquear a aplicação (era o [Future.delayed] com o [Dart]);
  • linhas 33–36 (.ts): um “servidor” simulado: uma função [async], que retorna uma [Promise]; sua resposta chega após um atraso aleatório (entre 200 e 800 milissegundos);
  • linhas 40–45 (.ts): um gerador assíncrono: uma função [async function*] (com um asterisco). Cada [yield] entrega um valor a quem percorre o gerador; entre dois valores, a função espera um segundo. Ele pode ser percorrido com um laço [for await (const n of countdown(20))].

A primeira contagem regressiva:

  • linha 67 (.ts): o gerador, convertido em [Observable] por [from()], que aceita um gerador assíncrono, uma [Promise], um array... Por convenção, o nome de uma variável que contém um [Observable] termina com [$];
  • Linha 23 (HTML): o pipe [async] assina o [Observable], exibe cada novo valor e cancela a assinatura automaticamente quando a página é fechada; ele vale [null] antes de o primeiro valor ser recebido. [@let n = ...] declara uma variável de template, lida na linha 24 ([n ?? '...']: três pontos enquanto [n] for igual a [null]). Como no [Flutter], o [Observable] é criado UMA ÚNICA VEZ em um campo da classe: se o template chamasse um método que o criasse, cada atualização da tela reiniciaria a contagem regressiva!

A segunda, com os operadores do [RxJS]:

  • linha 73 (.ts): [timer(0, 1000)] emite 0 imediatamente e depois 1, 2, 3... a cada segundo; o método [pipe] aplica operadores a ele, um após o outro: [take(21)] mantém apenas os 21 primeiros valores (depois o [Observable] termina); [map] transforma cada valor (0 vira 20, 1 vira 19...). [toSignal] assina o [Observable] e o transforma em um signal, que é igual ao último valor recebido ([undefined] antes do primeiro); ele cancela a assinatura quando a página é destruída;
  • linha 26 (HTML): o signal é lido como qualquer outro signal.

A [Promise] esperada:

  • linhas 77–82 (.ts): [resource()] recebe uma função [loader] que retorna uma [Promise], a invoca e expõe seu estado como signals: [isLoading()], [hasValue()], [value()], [error()]. Se fornecêssemos uma opção [params]—uma função que lê signals—, o resource seria recarregado sempre que eles mudassem (o [loader], porém, não é monitorado): vamos usá-la para consultar um servidor;
  • linhas 51–55 (HTML): enquanto a [Promise] não terminar, o conteúdo de espera; depois, o seu valor (era o [FutureBuilder] e o [ConnectionState.done]).

Busca durante a digitação:

  • linha 86 (.ts): um [Subject] é um [Observable] no qual nós mesmos EMPURRAMOS os valores ([next]): aqui, cada tecla digitada (linhas 111–113, disparadas pelo evento [(ionInput)] do campo, linha 36 do HTML);
  • linha 94 (.ts): debouncing: esperamos o usuário fazer uma pausa antes de consultar o servidor, em vez de enviar uma requisição a cada tecla. O operador [debounceTime(400)] só emite um valor após 400 milissegundos sem um novo valor: teclas digitadas muito próximas umas das outras são ignoradas. Com o [Flutter], era preciso cancelar e reiniciar manualmente um timer ([Timer]) a cada tecla;
  • linha 95 (.ts): o texto, sem espaços ao redor, em minúsculas;
  • linha 99 (.ts): respostas expiradas. Uma resposta que chega DEPOIS de outra busca ter sido iniciada deve ser ignorada: caso contrário, a resposta lenta de uma busca antiga sobrescreveria a da nova. O operador [switchMap] cuida disso: para cada texto, ele chama [launch], que retorna um [Observable] (a busca); quando um novo texto chega, ele CANCELA A ASSINATURA, interrompendo a busca anterior—cuja resposta nunca será transmitida—e então inicia a nova. Com o [Flutter], era necessário numerar as buscas e comparar os números;
  • Linha 101 (.ts): [takeUntilDestroyed()] encerra a assinatura quando a página é destruída: sem ele, o [Subject] e seus operadores continuariam a existir (era o [dispose] do [Flutter]). Ele deve ser chamado dentro de um “contexto de injeção”: neste caso, o construtor;
  • linha 103 (.ts): [subscribe] assina o [Observable]: nada acontece até que alguém assine. Cada lista de resultados é armazenada em um signal, que o template exibe (linhas 37–41 do HTML);
  • linhas 117–119 (.ts): menos de duas letras: nenhuma busca; [of([])] é um [Observable] que retorna imediatamente uma lista vazia;
  • linhas 123–130 (.ts): a busca: a [Promise] do servidor, transformada em [Observable] por [from()]. [tap] executa uma ação de passagem, sem modificar o valor: anota que a resposta chegou. [finalize] é chamado quando o [Observable] termina ou quando o usuário cancela a assinatura dele: se a resposta não chegou, significa que o [switchMap] abandonou essa busca, e isso é registrado no log.

Digitamos “p”, “pe” e “pel” rapidamente: uma única busca é enviada. Depois “du”, seguido de “dup” antes de a resposta a “du” chegar: a busca por “du” é abandonada (sua resposta é ignorada) no momento em que a busca por “dup” é enviada. À esquerda, a página ao abrir; à direita, cinco segundos depois:

No log, a linha “response ignored” precede a linha “search sent: ‘dup’”: [switchMap] cancela a assinatura da busca antiga antes de iniciar a nova.

No [Dart], [Future] e [Stream] fazem parte da biblioteca base, e [async], [await], [async*], [yield] e [await for] fazem parte da linguagem. No [JavaScript], [Promise], [async], [await] e os geradores assíncronos também estão incluídos na linguagem; mas, para sequências de valores, o [Angular] se apoia na biblioteca [RxJS], cujas cerca de cem operadores resolvem problemas como debouncing e respostas expiradas em uma única linha. O cliente HTTP do [Angular] (exemplos 22 a 25) também retorna [Observable]. Desde a chegada dos signals, o [Angular] reserva o [RxJS] para fluxos de eventos e usa [toSignal] ou [resource] para exibi-los.

6.2. Exemplo 20: Um estado compartilhado

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

  • O estado local de um componente desaparece quando o componente é destruído;
  • o estado de um “store” é compartilhado por todos os componentes e sobrevive à remoção deles… mas não ao encerramento da aplicação;
  • O estado armazenado no dispositivo sobrevive quando a aplicação é encerrada.

6.2.1. O carrinho de compras

// =========================================================================
// src/app/ex20-shared-state/stores/cart.ts - um ESTADO COMPARTILHADO: um serviço
// -------------------------------------------------------------------------
// Uma "store" é um estado que vive FORA das páginas e dos
// componentes, em UMA ÚNICA instância, compartilhada por todos que a leem.
// No Angular, é um SERVIÇO (veja o exemplo 14) cujo estado é feito de
// SIGNALS. Organização usual:
//   - o ESTADO: signals PRIVADOS (_items);
//   - sua leitura: views somente leitura (asReadonly);
//   - as AÇÕES: métodos, os únicos que modificam o estado;
//   - os valores calculados: signals computed.
// Um componente a obtém com inject(Cart); seu template, que lê os
// signals, é atualizado quando ELES mudam, e somente eles.
// providedIn: 'root': o serviço é criado na primeira solicitação e vive
// enquanto a aplicação viver: sobrevive à remoção de um componente... mas
// não à parada da aplicação.
// =========================================================================

import { computed, Injectable, signal } from '@angular/core';

export interface Item {
  label: string;
  price: number;
}

@Injectable({ providedIn: 'root' })
export class Cart {
  private readonly _items = signal<Item[]>([]);
  // uma view NÃO MODIFICÁVEL do estado: somente as ações o alteram
  readonly items = this._items.asReadonly();
  readonly count = computed(() => this._items().length);
  readonly total = computed(() => this._items().reduce((s, a) => s + a.price, 0));

  add(item: Item): void {
    // um NOVO array: o signal percebe que seu valor mudou
    this._items.update((items) => [...items, item]);
  }

  clear(): void {
    this._items.set([]);
  }
}

Um store é um estado que abrange páginas e componentes, existindo como uma instância única compartilhada por todos que o acessam. Com o [Angular], é simplesmente um serviço (veja o Exemplo 14) cujo estado é formado por signals: não há nenhuma biblioteca a adicionar, ao passo que o [Flutter] usava o pacote [provider] em torno de um [ChangeNotifier].

  • linha 26: [providedIn: 'root']: o serviço é criado na sua primeira solicitação ([inject(Cart)]), como uma instância única, e permanece ativo enquanto a aplicação estiver em execução;
  • linha 28: o estado: um signal privado;
  • Linha 30: uma view somente leitura do estado ([asReadonly()]): somente as ações o alteram;
  • Linhas 31–32: valores calculados: signals [computed], recalculados apenas quando a lista de itens muda;
  • Linhas 34–41: Ações: métodos, os únicos que modificam o estado. Linha 36: um NOVO array ([...items] copia os itens), e não [push] como na versão antiga: um signal compara os valores antigo e novo ([===]) e notifica seus assinantes somente se forem diferentes. Não é preciso escrever [notifyListeners()]: o signal cuida da notificação.

6.2.2. Preferências

// =========================================================================
// src/app/ex20-shared-state/stores/preferences.ts - um estado que sobrevive à parada
// -------------------------------------------------------------------------
// Para que um dado sobreviva à parada da aplicação, ele deve ser armazenado
// NO DISPOSITIVO. O "plugin" @capacitor/preferences oferece um pequeno
// dicionário chave -> valor (strings), específico da aplicação e
// mantido no dispositivo (Android: as SharedPreferences; em um
// navegador: o localStorage). Todos os seus métodos são ASSÍNCRONOS
// (retornam uma Promise):
//   - na inicialização, lemos os valores armazenados;
//   - a cada mudança, gravamos novamente.
// NUNCA armazenamos dados sensíveis aqui (senha, token): eles são
// gravados em texto puro.
// =========================================================================

import { effect, Injectable, signal } from '@angular/core';
// "as DeviceStorage": renomeado, para não confundir com nossa classe
import { Preferences as DeviceStorage } from '@capacitor/preferences';

const darkKey = 'example20.dark';
const sizeKey = 'example20.size';

@Injectable({ providedIn: 'root' })
export class Preferences {
  // o estado inicial: os valores padrão, enquanto se espera a leitura
  private readonly _dark = signal(false);
  private readonly _size = signal(16); // tamanho do texto
  readonly dark = this._dark.asReadonly();
  readonly size = this._size.asReadonly();

  constructor() {
    this.load();
    // um EFFECT: uma função reexecutada a cada vez que um signal que ela lê
    // muda. Ele aplica as preferências à aplicação INTEIRA:
    //   - a classe ion-palette-dark em <html>: o tema escuro do Ionic
    //     (veja styles.scss);
    //   - o tamanho da fonte de <html>: os componentes do Ionic
    //     têm tamanhos em rem (múltiplos desse tamanho), eles o acompanham
    effect(() => {
      document.documentElement.classList.toggle('ion-palette-dark', this._dark());
      document.documentElement.style.fontSize = `${this._size()}px`;
    });
  }

  // o que o dispositivo armazenou (value é null se a chave não existir)
  private async load(): Promise<void> {
    const dark = await DeviceStorage.get({ key: darkKey });
    const size = await DeviceStorage.get({ key: sizeKey });
    if (dark.value !== null) this._dark.set(dark.value === 'true');
    if (size.value !== null) this._size.set(Number(size.value));
  }

  // um parâmetro opcional por preferência: só alteramos o que for informado
  update({ dark, size }: { dark?: boolean; size?: number }): void {
    if (dark !== undefined) {
      this._dark.set(dark);
      DeviceStorage.set({ key: darkKey, value: String(dark) }); // gravação no dispositivo
    }
    if (size !== undefined) {
      this._size.set(size);
      DeviceStorage.set({ key: sizeKey, value: String(size) });
    }
  }
}

Para que os dados sobrevivam depois que a aplicação é fechada, eles precisam ser armazenados no dispositivo. O “plugin” [@capacitor/preferences] do [Capacitor] oferece um pequeno dicionário de chave-valor (de strings), específico da aplicação e armazenado no dispositivo: as [SharedPreferences] do [Android] (as mesmas usadas pelo pacote [shared_preferences] do [Flutter]) e, em um navegador, o [localStorage]. Todos os seus métodos são assíncronos: eles retornam uma [Promise].

  • linha 18: o plugin também se chama [Preferences]; [as DeviceStorage] o renomeia neste arquivo para evitar confusão com a nossa classe;
  • Linhas 26–29: O estado inicial, com signals definidos com seus valores padrão, e suas views somente leitura;
  • linha 32: A leitura do dispositivo começa quando o serviço é criado. Ela é assíncrona: por um breve instante, os valores padrão se aplicam;
  • linhas 39–42: um efeito ([effect]): uma função que é reexecutada toda vez que um signal que ela lê muda. Ela aplica as preferências a TODA a aplicação: a classe CSS [ion-palette-dark] na tag [<html>] ativa o tema escuro no [Ionic] (definido em [styles.scss]); o tamanho da fonte em [<html>] aumenta o texto, porque os componentes do [Ionic] expressam seus tamanhos em [rem] (como múltiplos desse tamanho). Um efeito serve a este propósito: repassar signals ao mundo externo (DOM, armazenamento etc.); ele não deve ser usado para calcular outros signals ([computed] foi concebido para isso);
  • linhas 46–51: operação de leitura do dispositivo: [DeviceStorage.get] retorna uma [Promise] de [{ value }], em que [value] é igual a [null] se a chave não existir. Os valores são strings: eles são convertidos;
  • linhas 54–63: uma única ação com parâmetros opcionais (um objeto desestruturado: [{ dark, size }]): somente o valor fornecido é alterado, e ele é imediatamente gravado no dispositivo ([DeviceStorage.set]). Não esperamos a conclusão da gravação: o signal já mudou.

NUNCA armazene dados sensíveis (senhas, tokens) ali: eles são gravados em texto simples. Para isso, existem plugins que usam o cofre do sistema (o [Keystore] do [Android], o [Keychain] do [iOS]).

6.2.3. Os componentes

// =========================================================================
// src/app/ex20-shared-state/components/shop.ts - ADICIONA ao carrinho compartilhado
// -------------------------------------------------------------------------
// A loja apenas CHAMA uma ação do carrinho; seu template não lê
// nenhum signal do carrinho: ela não é atualizada quando o carrinho muda.
// =========================================================================

import { CurrencyPipe } from '@angular/common';
import { Component, inject } from '@angular/core';
import { IonButton, IonCard, IonCardContent, IonCardHeader, IonCardSubtitle, IonIcon } from '@ionic/angular';
import { addIcons } from 'ionicons';
import { add } from 'ionicons/icons';
import { Item, Cart } from '../stores/cart';

const products: Item[] = [
  { label: 'Consultation', price: 30 },
  { label: 'Vaccine', price: 12.5 },
];

@Component({
  selector: 'app-ex20-shop',
  imports: [CurrencyPipe, IonCard, IonCardHeader, IonCardSubtitle, IonCardContent, IonButton, IonIcon],
  templateUrl: './shop.html',
})
export class Shop {
  readonly products = products;
  // o MESMO carrinho dos outros componentes (uma única instância)
  readonly cart = inject(Cart);

  constructor() {
    addIcons({ add });
  }
}
<!-- ======================================================================
     shop.html - dois produtos para adicionar ao carrinho
     ====================================================================== -->

<ion-card>
  <ion-card-header>
    <ion-card-subtitle>Shop</ion-card-subtitle>
  </ion-card-header>
  <ion-card-content>
    @for (p of products; track p.label) {
      <ion-button fill="clear" (click)="cart.add(p)">
        <ion-icon slot="start" name="add" />
        {{ p.label }} ({{ p.price | currency: 'EUR' }})
      </ion-button>
    }
  </ion-card-content>
</ion-card>
  • linha 28 (.ts): [inject(Cart)] retorna o MESMO carrinho de compras que os outros componentes;
  • linha 11 (html): a loja simplesmente chama uma ação. Seu template não lê nenhum signal do carrinho: ele não é atualizado quando o carrinho muda (era o [context.read<Cart>()] com o [provider]);
  • linha 13 (html): o pipe [currency] formata o preço no estilo inglês (veja o exemplo 09).
// =========================================================================
// src/app/ex20-shared-state/components/cart-summary.ts - LÊ o mesmo carrinho
// -------------------------------------------------------------------------
// O template lê dois signals do carrinho, count() e total(): ele é atualizado
// quando UM deles muda, e somente então.
// =========================================================================

import { CurrencyPipe } from '@angular/common';
import { Component, inject } from '@angular/core';
import { IonButton, IonCard, IonIcon, IonItem, IonLabel } from '@ionic/angular';
import { addIcons } from 'ionicons';
import { cart } from 'ionicons/icons';
import { Cart } from '../stores/cart';

@Component({
  selector: 'app-ex20-cart-summary',
  imports: [CurrencyPipe, IonCard, IonItem, IonIcon, IonLabel, IonButton],
  templateUrl: './cart-summary.html',
})
export class CartSummary {
  readonly cart = inject(Cart);

  constructor() {
    addIcons({ cart });
  }
}
<!-- ======================================================================
     cart-summary.html - o número de itens e o total do carrinho
     ====================================================================== -->

<ion-card>
  <ion-item lines="none">
    <ion-icon slot="start" name="cart" />
    <ion-label>{{ cart.count() }} item(s), {{ cart.total() | currency: 'EUR' }}</ion-label>
    <ion-button slot="end" fill="clear" [disabled]="cart.count() === 0" (click)="cart.clear()">
      Clear
    </ion-button>
  </ion-item>
</ion-card>
  • Linhas 8–9 (HTML): O template lê dois signals do carrinho, [count()] e [total()]: Ele é atualizado quando qualquer um deles muda, e somente então. Com o [provider], era preciso escolher entre [context.watch] (o carrinho inteiro) e [context.select] (um único item); com os signals, a precisão é automática: ela depende do que é lido.
// =========================================================================
// src/app/ex20-shared-state/components/local-counter.ts - um estado LOCAL
// -------------------------------------------------------------------------
// O signal clicks pertence ao componente: nasce com ele e desaparece
// com ele.
// =========================================================================

import { Component, input, signal } from '@angular/core';
import { IonButton, IonCard, IonItem, IonLabel } from '@ionic/angular';

@Component({
  selector: 'app-ex20-local-counter',
  imports: [IonCard, IonItem, IonLabel, IonButton],
  templateUrl: './local-counter.html',
})
export class LocalCounter {
  readonly title = input.required<string>();
  readonly clicks = signal(0);
}
<!-- ======================================================================
     local-counter.html - um contador de cliques
     ====================================================================== -->

<ion-card>
  <ion-item lines="none">
    <ion-label>{{ title() }}</ion-label>
    <ion-button slot="end" fill="outline" (click)="clicks.set(clicks() + 1)">{{ clicks() }} click(s)</ion-button>
  </ion-item>
</ion-card>

Um estado local (linha 18 do arquivo .ts), que é criado e destruído junto com o componente.

6.2.4. A página

// =========================================================================
// src/app/ex20-shared-state/ex20.page.ts - três "escopos" de dados
// -------------------------------------------------------------------------
//   - o estado LOCAL de um componente (LocalCounter) desaparece com ele;
//   - o estado de um SERVIÇO (o carrinho) é compartilhado por todos os componentes
//     e sobrevive à sua remoção - mas não à parada da aplicação;
//   - o estado armazenado no dispositivo (as preferências) sobrevive à parada.
// E a classe CSS ion-hide: o conteúdo fica OCULTO, mas não é removido; seu
// estado local é mantido.
// Desmarque e marque novamente "mostrar a área", depois pare e reinicie
// a aplicação: compare.
// =========================================================================

import { Component, inject, signal } from '@angular/core';
import {
  IonBackButton, IonButtons, IonCheckbox, IonContent, IonHeader, IonItem, IonLabel, IonList, IonRange, IonTitle,
  IonToggle, IonToolbar,
} from '@ionic/angular';
import { Shop } from './components/shop';
import { LocalCounter } from './components/local-counter';
import { CartSummary } from './components/cart-summary';
import { Preferences } from './stores/preferences';

@Component({
  selector: 'app-ex20',
  imports: [
    IonHeader, IonToolbar, IonButtons, IonBackButton, IonTitle, IonContent, IonList, IonItem, IonLabel, IonToggle,
    IonRange, IonCheckbox, Shop, CartSummary, LocalCounter,
  ],
  templateUrl: './ex20.page.html',
})
export class Ex20Page {
  readonly preferences = inject(Preferences);
  // um estado local da página
  readonly areaVisible = signal(true);
}
<!-- ======================================================================
     ex20.page.html - um estado compartilhado
     ====================================================================== -->

<ion-header>
  <ion-toolbar color="primary">
    <ion-buttons slot="start">
      <ion-back-button defaultHref="/" />
    </ion-buttons>
    <ion-title>Example 20 - a shared state</ion-title>
  </ion-toolbar>
</ion-header>

<ion-content class="ion-padding">
  <ion-list>
    <ion-item>
      <!-- [checked]: o valor do serviço; (ionChange): a ação que o modifica -->
      <ion-toggle [checked]="preferences.dark()"
        (ionChange)="preferences.update({ dark: $event.detail.checked })">dark theme</ion-toggle>
    </ion-item>
    <ion-item>
      <!-- snaps / ticks: marcas, a cada passo -->
      <ion-range [min]="12" [max]="22" [step]="1" [snaps]="true" [ticks]="true" [value]="preferences.size()"
        (ionChange)="preferences.update({ size: +$event.detail.value })">
        <ion-label slot="label">text size: {{ preferences.size() }}</ion-label>
      </ion-range>
    </ion-item>
    <ion-item>
      <ion-checkbox [checked]="areaVisible()" (ionChange)="areaVisible.set($event.detail.checked)">
        show the area</ion-checkbox>
    </ion-item>
  </ion-list>

  <!-- removido: esses componentes desaparecem, com seu estado local -->
  @if (areaVisible()) {
    <app-ex20-shop />
    <app-ex20-cart-summary />
    <app-ex20-local-counter title="Local state" />
  }
  <!-- oculto (ion-hide: display none): o componente permanece na memória, seu estado é mantido -->
  <app-ex20-local-counter title="Local state, hidden by a CSS class" [class.ion-hide]="!areaVisible()" />

  <p>Outside the area, a second summary of the SAME cart (it stays there when the area disappears):</p>
  <app-ex20-cart-summary />
</ion-content>
  • linha 33 (.ts): as preferências, um serviço; ele é criado (e lê o dispositivo) na primeira solicitação;
  • linha 35 (.ts): um estado local da página: a área está sendo exibida?
  • linhas 18–19 (html): um interruptor ([<ion-toggle>]): [[checked]] recebe o valor do serviço, e [(ionChange)] chama a ação dele;
  • linhas 23–26 (html): um controle deslizante ([<ion-range>]) variando de 12 a 22, com marcas de graduação ([snaps], [ticks]); [+$event.detail.value] converte o valor em número;
  • linhas 29–30 (html): uma caixa de seleção, vinculada ao estado local;
  • linhas 35–39 (HTML): removida ([@if]); a área desaparece—seus componentes são DESTRUÍDOS, junto com o estado local deles;
  • linha 41 (html): ocultada pela classe CSS [ion-hide] do [Ionic] ([display: none]); o componente permanece na memória: seu estado é preservado. [[class.ion-hide]="..."] define a classe quando a expressão é verdadeira. (Antes era o [Visibility(maintainState: true)] do [Flutter].)
  • Linha 44 (html): um segundo resumo do mesmo carrinho, fora da área.

O carrinho e as preferências são compartilhados por toda a aplicação ([providedIn: 'root']). Para tornar um serviço específico de uma página (uma instância por página, destruída junto com ela), ele é declarado nos [providers] do seu componente, como mostrado no Exemplo 21.

6.2.5. Execução

Adicionamos dois itens, clicamos duas vezes no primeiro contador local e uma vez no segundo (à esquerda); removemos a área e passamos para o tema escuro (no meio); restauramos a área (à direita):

O carrinho sobreviveu à remoção da seção (como mostra o segundo resumo); o contador removido voltou a zero; o contador oculto manteve seu valor. Pare a aplicação e reinicie-a (no navegador: recarregue a página): o tema escuro e o tamanho do texto são preservados, e o carrinho está vazio. As preferências se aplicam a toda a aplicação: ao voltar ao menu, ele também está no modo escuro.

Por que não usar uma biblioteca de gerenciamento de estado? Existem algumas disponíveis para o [Angular] ([NgRx], sua variante [SignalStore], [NGXS]...), assim como existem para o [Flutter] ([provider], [Riverpod], [Bloc]...). Mas a injeção de dependência e os signals já cuidam do essencial: um serviço baseado em signals é um store, e é isso que o estudo de caso usará.