Apps Flutter sonham com widgets cientes da plataforma?
Layout agnóstico com widgets específicos de plataforma
Flutter é um novo framework de desenvolvimento multiplataforma que promete liberdade absoluta na criação de experiências de usuário, independentemente da plataforma hospedeira. Ele consegue isso assumindo o pipeline de renderização e gerenciando tudo por conta própria, desde o layout dos componentes até o desenho deles. Personalizar tudo é o que dá vida ao Flutter. Aplicações que usam uma linguagem de design de marca muito forte são um alvo óbvio para essa independência de plataforma. Pense na Netflix: ela parece e se comporta igual, seja no seu iPhone, no Android ou no PlayStation.
Mas e as marcas que querem manter uma aparência e sensação específicas de cada plataforma? Muitas empresas adotam o Material Design ou a linguagem Human Interface do iOS para manter seus clientes em um ambiente familiar.
O Flutter tem pacotes que contêm um conjunto robusto de widgets nativos para iOS e Android, chamados Cupertino e Material.
O framework é agnóstico em sua essência quando se trata de UI. No entanto, alguns widgets exigem um ancestral que pertence à mesma biblioteca “específica de plataforma”. Por exemplo, RaisedButton pertence à biblioteca do pacote Material e exige que um widget Material seja um de seus ancestrais. Isso apresenta aos desenvolvedores um problema em termos de reutilização do código de layout.
Uma das perguntas que mais recebo da área de negócios é — “mas dá para criar apps com aparência nativa de forma eficiente e ainda ter código reutilizável?”
Essa é uma pergunta válida se estivermos buscando essa aparência e sensação nativas. Minha reação a uma pergunta assim seria: sim, podemos construir duas árvores de layout “nativas”, uma para cada plataforma hospedeira. Simples, certo?
Bem, nem tanto. Estaríamos nos enganando ao criar duas implementações, exatamente o oposto do que buscamos. As duas árvores são inerentemente diferentes, já que cada plataforma tem necessidades diferentes em termos de dependências e inicialização. Nossa sagrada busca por código reutilizável se desfaz.
Gostaria de propor uma abordagem que permite construir uma UI abstrata e ajustar sua aparência e comportamento conforme a plataforma em que ela roda.
Considere os seguintes construtores para dois widgets que fornecem uma barra superior de app:
CupertinoNavigationBar ({
this.leading,
this.middle,
})
e
AppBar({
this.leading,
this.title
})
Ambos desempenham o mesmo papel, fornecendo uma barra de aplicativo superior em estilo Cupertino e Material, mas ainda assim exigem algumas propriedades diferentes. Precisamos de uma solução que abstraia a forma como instanciamos tipos específicos e forneça implementações com base na plataforma hospedeira. Vamos recorrer ao velho truque do padrão Factory Method.
import 'package:flutter/material.dart';
import 'dart:io' show Platform;
abstract class PlatformWidget<I extends Widget, A extends Widget> extends StatelessWidget {
@override
Widget build(BuildContext context) {
if (Platform.isAndroid) {
return createAndroidWidget(context);
} else if (Platform.isIOS) {
return createIosWidget(context);
}
// Not supported platforms return an empty widget.
return new Container();
}
I createIosWidget(BuildContext context);
A createAndroidWidget(BuildContext context);
}
Em essência, trata-se de uma Factory de widgets específicos de plataforma que usa o StatelessWidget do framework como interface.
Quando implementada, a classe acima pode fornecer um construtor personalizado (ou vários construtores nomeados) que atenda às necessidades das duas classes concretas.
Observação: o motivo de eu ter escolhido generics para retornar classes concretas específicas é que, às vezes, o widget pai vai precisar de um tipo específico retornado pelo widget filho.
Feito isso, podemos implementar nosso primeiro widget com consciência de plataforma.
class PlatformAppBar extends PlatformWidget<CupertinoNavigationBar, AppBar> {
final Widget leading;
final Widget title;
PlatformWidget({
this.leading,
this.title,
});
@Override
CupertinoNavigationBar createIosWidget(BuildContext context) => new CupertinoNavigationBar(
leading: leading,
middle: title,
);
@Override
AppBar createAndroidWidget(BuildContext context) =>
new AppBar(
leading: leading,
title: title,
);
}
Bem simples, né? Repare que temos controle total sobre o conteúdo dos widgets da barra de aplicativo e sobre a forma como os instanciamos.
Por uma questão de tempo, vamos supor que também implementamos um scaffold e um botão.
class PlatformScaffoldWidget extends PlatformWidget<CupertinoPageScaffold,Scaffold> {
// ...
}
class PlatformButton extends PlatformWidget<CupertinoButton,FlatButton> {
// ...
}
Agora estamos prontos para usar (e reutilizar) nossos widgets cientes da plataforma.
Widget build(BuildContext context) =>
new PlatformScaffoldWidget(
appBar : new PlatformAppBarWidget(
leading: new PlatformButton (
child: new Icon(Icons.ic_arrow_back),
onClick: () => _handleBack()
),
title: new Text ("I love my Platform"),
),
content: ...
);
E pronto! O código acima vai renderizar uma barra de app com aparência nativa em ambas as plataformas, e nosso PlatformScaffoldWidget está pronto para ser reutilizado em todo o resto do app sem complicações. Dê uma olhada e me diga o que você acha