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:
$ flutter channel dev
$ flutter upgrade
Agora, você precisa habilitar o suporte à web para que o Flutter possa configurar seu app para rodar na web:
$ 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:
$ 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):
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:
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.
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):
$ 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:
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:
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 paraweb: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_pluginspermite registrar a implementação web deurl_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:
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):
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!