Padrão Adapter

Parte da seção Programação Orientada a Objetos do Journey de Dart da Coddy. Lição 95 de 110.

O padrão Adapter permite que interfaces incompatíveis trabalhem juntas. Ele atua como uma ponte entre duas classes que, de outra forma, não poderiam colaborar, encapsulando uma classe existente com uma nova interface que os clientes esperam. Isso é particularmente útil ao integrar bibliotecas de terceiros ou código legado ao seu aplicativo.

Imagine que você tenha um sistema que trabalha com dados JSON, mas precise integrar um componente que gera apenas XML. Em vez de modificar qualquer uma das classes, você cria um adaptador que traduz entre elas:

// Interface existente que seu sistema espera
abstract class JsonData {
  String getJson();
}

// Classe legada com interface incompatível
class XmlService {
  String getXml() {
    return '<data><name>John</name></data>';
  }
}

// Adapter torna XmlService compatível com JsonData
class XmlToJsonAdapter implements JsonData {
  final XmlService _xmlService;

  XmlToJsonAdapter(this._xmlService);

  @override
  String getJson() {
    String xml = _xmlService.getXml();
    // Converte XML para JSON (simplificado)
    return '{"name": "John"}';
  }
}

void main() {
  var xmlService = XmlService();
  var adapter = XmlToJsonAdapter(xmlService);

  print(adapter.getJson());  // {"name": "John"}
}

O XmlToJsonAdapter encapsula o XmlService e implementa a interface JsonData. O código cliente trabalha com a conhecida interface JsonData sem saber que os dados vieram originalmente de uma fonte XML. O adaptador lida internamente com toda a tradução.

Use o padrão Adapter quando quiser usar uma classe existente, mas a interface dela não corresponder ao que você precisa, ou quando precisar criar uma classe reutilizável que coopere com classes que tenham interfaces incompatíveis.

Desafio

Fácil

Vamos criar um sistema de adaptador para um reprodutor de mídia! Imagine que você tem um sistema de áudio moderno que espera que todas as fontes de mídia forneçam áudio por meio de uma interface padrão, mas precisa integrar um toca-discos de vinil antigo que tem uma maneira completamente diferente de produzir som.

Você criará dois arquivos para organizar sua implementação do padrão adapter:

media_adapter.dart: Este arquivo contém suas classes de interface e adaptador. Defina uma classe abstrata AudioSource que seu sistema moderno espera — ela deve ter um método String playAudio() que retorna a saída de áudio como uma string. Em seguida, crie uma classe VinylPlayer que represente o equipamento legado — ela tem um campo trackName e um método String spinRecord() que retorna *crackle* Playing vinyl: [trackName] *crackle*. Por fim, crie um VinylAdapter que implemente AudioSource e envolva um VinylPlayer. O método playAudio() do adaptador deve chamar o método spinRecord() do toca-discos e retornar o resultado — conectando as interfaces incompatíveis.
main.dart: Importe seu arquivo do adaptador de mídia e demonstre como o adaptador faz o antigo toca-discos funcionar com código que espera a interface moderna AudioSource. Crie um VinylPlayer com o nome da faixa Bohemian Rhapsody. Em seguida, crie um VinylAdapter que envolva esse toca-discos. Armazene o adaptador em uma variável do tipo AudioSource para provar que ele está em conformidade com a interface esperada. Chame playAudio() na sua fonte de áudio e imprima o resultado.

A beleza desse padrão é que seu código principal trabalha com a interface padrão AudioSource — ele não precisa saber que, nos bastidores, um antigo toca-discos está fazendo o trabalho de fato!

Saída esperada:

*crackle* Playing vinyl: Bohemian Rhapsody *crackle*

Experimente você mesmo

import 'media_adapter.dart';

void main() {
  // TODO: Crie um VinylPlayer com o nome da faixa "Bohemian Rhapsody"
  
  // TODO: Crie um VinylAdapter que envolve o vinyl player
  
  // TODO: Armazene o adapter em uma variável do tipo AudioSource
  
  // TODO: Chame playAudio() na sua fonte de áudio e imprima o resultado
  
}