Como escrever um plugin web para Flutter

Aprenda os fundamentos para criar um plugin web do Flutter e conectar APIs Dart a implementações no navegador.

Você quer adicionar suporte a um plugin do Flutter? Este artigo vai mostrar como o suporte à web foi adicionado ao plugin url_launcher. Antes de ler este artigo, você já deve estar familiarizado com desenvolvimento de plugins e com os conceitos em Desenvolvendo pacotes de plugin.

Exemplo: package:url_launcher

Primeiro, vamos criar um app de exemplo que usa package:url_launcher, para que você possa verificar se ele funciona corretamente.

Configuração

Para usar plugins web, você precisa estar no canal dev do Flutter. Certifique-se de estar no canal dev executando:

bash
$ flutter channel dev
$ flutter upgrade

Agora, você precisa habilitar o suporte à web para que o Flutter possa configurar seu app para rodar na web:

bash
$ flutter config --enable-web

Agora, crie um diretório chamado url_launcher_example (vamos supor que seja ~/url_launcher_example) e crie um projeto Flutter nele:

bash
$ mkdir "~/url_launcher_example"
$ cd "~/url_launcher_example"
$ flutter create .

Usando package:url_launcher

Nosso app de exemplo terá apenas um botão que abre o google.com.

Primeiro, atualize o pubspec para depender de package:url_launcher. Em pubspec.yaml, na seção dependencies, adicione a linha (destacada em negrito):

yaml
name: url_launcher_example
# ...
dependencies:
  flutter:
    sdk: flutter
  url_launcher: 5.2.3
  # ...

Agora, substitua todo o conteúdo de lib/main.dart pelo seguinte:

dart
import 'package:url_launcher/url_launcher.dart';
import 'package:flutter/material.dart';
​
void main() => runApp(UrlLauncherExample());
​
class UrlLauncherExample extends StatelessWidget {
  static const String _title = 'URL Launcher Example';
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: _title,
      home: Scaffold(
        appBar: AppBar(title: const Text(_title)),
        body: LaunchButton(),
      ),
    );
  }
}
​
class LaunchButton extends StatelessWidget {
  LaunchButton({Key key}) : super(key: key);
​
  @override
  Widget build(BuildContext context) {
    return Center(
      child: RaisedButton(
        onPressed: _launch,
        child: Text(
          'Launch!',
          style: TextStyle(fontSize: 20),
        ),
      ),
    );
  }
​
  void _launch() {
    launch('https://www.google.com');
  }
}

Verifique se o app funciona executando-o no seu dispositivo Android ou iOS, ou no simulador, rodando o app normalmente com flutter run. O app deve ter a aparência desta captura de tela. Tente clicar no botão Launch! e verifique se ele abre o Google.

App de exemplo do URL Launcher
App de exemplo do URL Launcher

Agora, você pode executar o mesmo app na web com flutter run -d chrome. O app deve abrir e renderizar exatamente como a versão mobile, mas clicar em Launch! não faz nada. Vamos começar a escrever o plugin web para url_launcher.

Criando package:url_launcher_web

Crie um novo diretório chamado url_launcher_web (vamos supor que seja ~/url_launcher_web):

bash
$ mkdir "~/url_launcher_web"
$ cd "~/url_launcher_web"

Infelizmente, não há template para plugins web no momento (ou seja, você não pode usar flutter create), então você terá que criar o plugin manualmente. Mas, antes de começar a programar, convém discutir como isso será de fato implementado.

Analisando package:url_launcher

Vamos ver como package:url_launcher é implementado, para que você saiba o que fazer para package:url_launcher_web. O código principal pode ser encontrado aqui. Estes são os principais pontos que você deve observar:

dart
const MethodChannel _channel = MethodChannel('plugins.flutter.io/url_launcher');
​
Future<bool> launch(
  String urlString, {
  ...
}) async {
  assert(urlString != null);
  final bool result = await _channel.invokeMethod<bool>(
    'launch',
    <String, Object>{
      'url': urlString,
      ...
      },
  );
  ...
  return result;
}

Quase todos os plugins do Flutter são escritos assim. Eles criam um MethodChannel, e então o plugin funciona enviando uma chamada de método pelo canal para o lado da “plataforma” (ou seja, Android ou iOS) do plugin. Assim, a forma como esse plugin funciona no Android é que existe um código, escrito em Java, que registra um MethodChannel do lado Android. O MethodChannel aguarda chamadas de método, que chamam o código Android necessário para abrir uma URL. Para fazer esse plugin funcionar na web, você precisa fazer a mesma coisa que nas implementações Android e iOS: criar um MethodChannel que aguarda chamadas de método e, quando o MethodChannel as recebe, abre a URL informada.

Implementando package:url_launcher_web

Implementações web de plugins do Flutter são escritas como pacotes Dart. Vamos começar com o pubspec.yaml. Supondo que você esteja no diretório url_launcher_web que criou antes, crie um arquivo chamado pubspec.yaml e cole o código a seguir nele:

yaml
name: url_launcher_web
version: 0.0.1
​
flutter:
  plugin:
    platforms:
      web:
        pluginClass: UrlLauncherPlugin
        fileName: url_launcher_web.dart
​
dependencies:
  flutter:
    sdk: flutter
  flutter_web_plugins:
    sdk: flutter
​
environment:
  sdk: ">=2.0.0-dev.28.0 <3.0.0"
  flutter: ">=1.5.0 <2.0.0"

Alguns pontos-chave a observar:

  • A seção platforms: contém uma seção para web: que declara o nome da classe onde você vai implementar o plugin, além do nome do arquivo que contém a classe.

  • A dependência flutter_web_plugins permite registrar a implementação web de url_launcher.

Declaramos que nossa implementação será uma classe chamada UrlLauncherPlugin e escrita em url_launcher_web.dart, então vamos escrever essa classe agora. Certifique-se de criar primeiro um diretório lib/ e depois editar lib/url_launcher_web.dart e colar o código a seguir no arquivo:

dart
import 'dart:async';
import 'dart:html' as html;
​
import 'package:flutter/services.dart';
import 'package:flutter_web_plugins/flutter_web_plugins.dart';
​
class UrlLauncherPlugin {
  static void registerWith(Registrar registrar) {
    final MethodChannel channel = MethodChannel(
        'plugins.flutter.io/url_launcher',
        const StandardMethodCodec(),
        registrar.messenger);
    final UrlLauncherPlugin instance = UrlLauncherPlugin();
    channel.setMethodCallHandler(instance.handleMethodCall);
  }
​
  Future<dynamic> handleMethodCall(MethodCall call) async {
    switch (call.method) {
      case 'launch':
        final String url = call.arguments['url'];
        return _launch(url);
      default:
        throw PlatformException(
            code: 'Unimplemented',
            details: "The url_launcher plugin for web doesn't implement "
                "the method '${call.method}'");
    }
  }
​
​
  bool _launch(String url) {
    return html.window.open(url, '') != null;
  }
}

Há vários pontos importantes a observar em nossa implementação; vamos analisá-los um por um.

Registrando o plugin com registerWith

Assim como no Android ou iOS, os plugins web precisam fazer alguma inicialização antes de o app rodar. Isso é feito no método estático registerWith, que recebe um Registrar (que vem de package:flutter_web_plugins).

Neste caso, estamos registrando um MethodChannel para escutar mensagens recebidas do app. Repare em como inicializamos o MethodChannel com registrar.messenger. Todos os MethodChannels têm um BinaryMessenger que usam para enviar e receber mensagens. Por padrão, um MethodChannel usa o BinaryMessenger padrão definido no Flutter. O BinaryMessenger envia mensagens do app para o lado da plataforma, mas estamos escrevendo um plugin que fica do lado da plataforma e deve receber mensagens do app, então precisamos inicializar o MethodChannel com um BinaryMessenger diferente. Felizmente, o Registrar que é passado para o plugin em registerWith tem um messenger que faz a coisa certa. Ao inicializar nosso MethodChannel com ele, agora temos um MethodChannel que recebe chamadas de método do app.

Tratando chamadas de método

O MethodChannel que criamos registrou handleMethodCall como seu manipulador de chamadas de método. Isso significa que sempre que o MethodChannel do lado do app (o criado em package:url_launcher) enviar uma chamada de método para o MethodChannel do lado da plataforma (o que criamos em registerWith), esse manipulador de chamadas de método será invocado.

Se o manipulador receber uma chamada de método para o método 'launch', ele invoca _launch, que simplesmente abre uma nova janela com a URL informada.

Usando o plugin web no app de exemplo

Nosso plugin web está ficando bom! Agora, precisamos usá-lo a partir do app de exemplo que criamos antes.

Modifique o pubspec em ~/url_launcher_example para adicionar uma dependência de ~/url_launcher_web. Sua alteração deve ficar parecida com isto. (Certifique-se de usar o caminho correto para onde você colocou seus diretórios):

yaml
dependencies:
  flutter:
    sdk: flutter
  url_launcher: 5.2.3
  url_launcher_web:
    path: ../url_launcher_web

Agora, execute o app de exemplo novamente com flutter run -d chrome. Tente clicar no botão Launch!. Ele deve abrir o google.com em uma nova aba.

Parabéns! Você adicionou com sucesso suporte à web a um plugin do Flutter!

Mais do Flutter