Adaptabilidade extrema de UI no Flutter — como o Google Earth atende a todos os casos de uso do planeta

Veja como o Google Earth usa Flutter para adaptar sua interface a celulares, tablets, dobráveis e à web.

Adaptabilidade extrema de UI no Flutter — Como o Google Earth dá suporte a todo caso de uso da Terra

Quando o Google Earth decidiu reescrever seus clientes móveis e web em Flutter, sabia que queria permitir que cada um dos seus usuários explorasse o planeta do jeito que quisesse, em qualquer dispositivo que tivesse. Isso já era verdade até certo ponto; afinal, o Google Earth já tinha clientes para web, desktop, Android e iOS. Mas esta reescrita, que cobriria todos esses alvos exceto desktop, precisaria dar suporte ao conjunto completo de casos de uso existentes, além de algumas novas ideias de adaptabilidade que a equipe do Earth estava animada para explorar.

A busca pela stack tecnológica do futuro do Google Earth foi fortemente influenciada por fontes de atrito bem conhecidas que vinham desacelerando o desenvolvimento de seus clientes atuais. Em especial, o Google Earth há muito tempo era forçado a escolher entre velocidade de desenvolvimento de novas funcionalidades e manutenção da paridade de funcionalidades entre suas três bases de código distintas (web, Android e iOS). Felizmente, o centro da UI — todo o pontinho azul-claro no meio da tela — é alimentado por uma engine em C++ que já oferecia uma experiência unificada para algumas funcionalidades do Google Earth. No entanto, o restante da interface e os menus eram implementados separadamente em cada base de código. Isso significava que qualquer escolha multiplataforma não só precisaria reformular o processo de desenvolvimento de UI, como também se integrar a uma grande engine legada em Android, iOS e web.

Os fatores decisivos para usar Flutter foram dois. Primeiro, integrar-se à engine existente do Google Earth se mostrou uma tarefa simples usando method channels. Segundo, o Google Earth não queria apenas simplificar suas bases de código, mas também reimaginar sua UI por completo. Qualquer grande reformulação de UI já é, em certa medida, uma reescrita, e o Google Earth optou por escrever um único app Flutter novo em vez de fazer cirurgia em três apps existentes. Isso complicou a tarefa, mas a equipe se comprometeu com uma ruptura limpa e com um foco obsessivo em adaptabilidade. No fim, a equipe do Google Earth passou a usar Flutter para alimentar a UI nas três plataformas.

Definindo adaptabilidade

E assim, a equipe do Google Earth partiu para uma aventura para expandir os limites da adaptabilidade de UI. Existe muita coisa já feita sobre criar UIs adaptadas a diferentes jornadas de usuário — desde o surgimento dos smartphones e a percepção coletiva da internet de que a maioria dos sites precisava ser repensada para telas pequenas. APIs de navegador e padrões de CSS surgiram para criar sites conscientes da resolução da tela, e essas ideias têm estado em evidência desde então. Mesmo nos primeiros dias do Flutter, os desenvolvedores já sabiam que as telas dos celulares variam e faziam a UI de seus apps depender da resolução da tela. E se essa resolução mudasse — seja porque o usuário girou o celular ou redimensionou a janela do navegador — a UI do app precisava responder. No Flutter, assim como na web por anos antes dele, UIs responsivas melhoraram a experiência do usuário.

Você pode se perguntar qual é a diferença entre uma UI responsiva e uma UI adaptativa. Em termos simples, uma UI responsiva se ajusta a mudanças na quantidade e na proporção dos pixels disponíveis; já uma UI adaptativa se ajusta a todo o resto. UIs responsivas podem aumentar ou diminuir elementos individuais da interface com base em detalhes do espaço da tela, mas UIs adaptativas respondem a perguntas mais fundamentais, como onde renderizar a navegação do app, se listas devem abrir visualizações de detalhe separadas ou mostrá-las lado a lado com a própria lista, e como os periféricos conectados do usuário devem influenciar coisas como áreas de toque e estados de hover (mais sobre esse conceito adiante).

Para saber mais, assista ao episódio 15 do Decoding Flutter sobre UIs adaptativas versus responsivas e veja estes guias da Flutter e da documentação do Android.

Como qualquer pessoa que já escreveu CSS responsivo para um site vai dizer, até UIs simples escondem casos extremos complicados. E, para ser claro, isso não é culpa do CSS; o espaço de problemas tem tantos estados detalhados que quase parece analógico. O que, então, um desenvolvedor de UI deve esperar ao considerar variáveis adicionais, como o formato do dispositivo e os periféricos conectados? Naturalmente, deve esperar um aumento considerável de complexidade.

Isso chegou ao ápice quando o comportamento de um protótipo inicial pegou a equipe do Google Earth de surpresa. Enquanto testava uma versão inicial, um engenheiro do Google Earth reduziu a largura do navegador de desktop a um tamanho extremamente estreito. De repente, elementos típicos de desktop, como barras de navegação laterais e áreas de toque mais compactas, foram substituídos por elementos de mobile, como uma barra de navegação inferior e botões maiores, pensados para o toque com o dedo. A surpresa foi breve — afinal, era exatamente isso que eles tinham dito ao app para fazer. A equipe do Google Earth agora se via diante de uma pergunta profunda — é isso que um usuário gostaria?

Esse era o território desconhecido que a equipe do Google Earth estava prestes a mapear.

Por que adaptabilidade?

Para alguns, o conteúdo a seguir levanta uma metapergunta: Por que se dar ao trabalho de tudo isso, afinal? O retorno é suficiente, quando uma UI responsiva certamente atenderia à maioria dos usuários?

São boas perguntas, mas elas não devem gerar hesitação em relação ao Flutter. Usar um framework de UI multiplataforma como o Flutter não introduz preocupações de UI adaptativa; ele desbloqueia soluções de UI adaptativa. Além disso, há duas considerações que mostram que UIs adaptativas realmente são tão importantes assim:

  • As resoluções de tela não significam mais o que já significaram. Navegadores de desktop podem ter configurações de DPI baixas que uma verificação ingênua de breakpoint confundiria com ambientes mobile; celulares de alta densidade de pixels em orientação paisagem podem ser confundidos com breakpoints antigos de tablet (ou até de desktop!); e dispositivos dobráveis podem alternar entre mostrar o app em tela cheia e dividir a área da tela entre vários apps, causando diferenças bruscas se isso jogar o usuário de um lado para o outro entre determinados breakpoints.

  • Apps com modos distintos de criação e consumo (pense em qualquer app de composição de texto com as experiências de leitura e edição) podem sofrer muito no mobile — e principalmente em tablets. Entregar uma experiência mobile-first, e portanto provavelmente voltada primeiro ao consumo, para smartphones e tablets limita bastante seus usuários avançados que têm um tablet, um teclado Bluetooth e um mouse.

Entregando adaptabilidade

A equipe do Google Earth percorreu um longo caminho de experimentação, pesquisa com usuários e iteração até chegar ao app que finalmente lançou. Mas, no fim, o problema se resumia a três perguntas de alto nível:

  1. Como o app deve determinar sua estratégia inicial de UI?

  2. Como e quando o app deve mudar sua estratégia de UI?

  3. Como a equipe do Google Earth implementaria essa lógica de forma limpa?

Definindo uma estratégia inicial de UI

Uma das premissas iniciais da equipe do Earth era de que “não há diferença entre um Chromebook com tela sensível ao toque e um tablet com um teclado Bluetooth conectado”, e que a UI não deveria distinguir os dois. Embora essa ideia fizesse sentido no começo, ela não resistiu aos testes, e, com o tempo, a equipe percebeu cada vez mais as lacunas dessa abordagem. Um usuário que abrisse o app em um tablet de alta resolução na horizontal poderia ficar dentro da faixa de resolução de pixels da UI de desktop (seguindo as regras antigas de UI responsiva). Se esse mesmo usuário girasse o tablet para o modo retrato e, com isso, passasse para uma faixa de resolução de pixels atribuída a tablets, o Google Earth ficaria diante de uma escolha difícil. A opção dinâmica seria reestruturar tudo de uma vez, trocando a UI de desktop pela UI de mobile; já a opção estática seria não fazer nada além de espremer e comprimir a UI de desktop até caber nas novas restrições. Nenhuma das duas opções era satisfatória, e tudo isso significava que havia uma diferença entre um Chromebook com tela sensível ao toque e um tablet com teclado.

No fim, a equipe do Earth adotou uma regra simples: oferecer a experiência mobile para smartphones e tablets, e a experiência de desktop para computadores. Se isso parece anticlimático, bom, de certa forma é; mas só porque deixa para a próxima pergunta as partes mais interessantes — Quando a estratégia inicial da UI deve mudar?

Atualizando a estratégia de UI dentro de uma sessão do usuário

A primeira estratégia da equipe para mudanças de UI era pouco mais do que as regras clássicas de UI responsiva: mostrar a UI mobile em qualquer resolução abaixo de um limite mínimo, a UI de tablet (se houvesse uma) nas próximas centenas de larguras possíveis e, por último, a UI de desktop em todos os demais casos. E, o mais importante, sempre que uma UI cruzasse um desses limites por qualquer motivo, o app era renderizado novamente de acordo. Claro que a estranheza desse conjunto de regras acabou levando o Google Earth à sua odisseia de adaptabilidade extrema; por isso não surpreende que a equipe tenha abandonado essa abordagem.

Uma segunda possibilidade veio do Stadia, outra equipe do Google com um app mobile Flutter de sucesso. (Obviamente, o Stadia não sobreviveu como produto, mas não foi por falta de funcionalidade no app mobile!) A abordagem do Stadia era tomar decisões de adaptação com base em qual entrada foi tocada por último. Arrastar o cursor do computador ou pressionar uma tecla fazia o Stadia mudar para o modo de UI de desktop. Por outro lado, se você inclinasse um joystick de um controle de console conectado, o Stadia mudava para o modo de UI de console. No entanto, embora isso fizesse sentido para o Stadia, não era tão adequado para o Google Earth. Um caso simples descartava essa estratégia de “última entrada tocada”: um usuário de tablet que dá zoom no mapa com pinça e depois volta a um teclado Bluetooth para terminar de digitar um conteúdo. Nenhum usuário quer duas transições dramáticas de UI nessa interação simples, então as entradas mais recentes do usuário não podiam trocar por completo a UI do Google Earth de mobile para desktop, ou vice-versa.

No fim, a equipe do Google Earth adotou uma segunda regra bem simples: manter a consistência dentro de uma sessão e nunca abandonar a UI inicial sem a permissão explícita do usuário. Como explorado antes, o Google Earth mostraria sua UI mobile-first em smartphones e tablets, e sua UI desktop-first em computadores; e nunca tentaria ser mais esperto que o próprio usuário para mudar isso, a menos que ele pedisse uma alteração no painel de configurações.

Estados de UI mistos

A consistência da UI dentro das sessões serviu bem ao Google Earth, mas não é a história completa. Elementos de interação de experiências de desktop, como os efeitos de hover do cursor, não têm equivalente no mobile e precisam ser reimaginados. Um usuário que trata o notebook com tela sensível ao toque como um tablet poderia ficar totalmente bloqueado caso o app não substituísse os efeitos de hover essenciais por alternativas adequadas ao mobile. Essa percepção sugeriu um problema e uma solução em dois níveis. A UI do Google Earth não só precisaria alternar suavemente entre as experiências mobile e desktop quando o usuário pedisse, como também cada controle individual precisaria ter uma forma amigável ao toque e uma forma amigável ao mouse, independentemente da estratégia geral.

Por fim, o Google Earth sabia o que estava construindo. Toda a pesquisa e as iterações deixaram apenas questões de implementação, que se resumiam a:

  1. Como gerenciar as transições entre duas UIs fundamentalmente diferentes, e

  2. Como construir controles individuais que deem suporte a periféricos atípicos

Gerenciando múltiplas UIs

Na forma mais simples, construir qualquer app Flutter que alterne perfeitamente entre duas experiências diferentes é tão simples quanto colocar a seguinte linha em algum lugar do método build de um widget:

dart
child: mode == Mode.desktop ? DesktopUI() : MobileUI()

No entanto, esta estratégia (que é a usada pelo Google Earth) implica algum trabalho extra em outros pontos para ser plenamente realizada. O problema — inicialmente discreto — surge quando qualquer estado da aplicação é armazenado dentro de um widget Stateful, já que alternar essa mode variável substitui completamente a árvore de widgets, destruindo todos os objetos State e qualquer informação que eles guardam. Há duas camadas nesse problema.

Para imaginar a primeira camada, considere uma tela com vários painéis no desktop, mas que reorganiza cada um desses painéis em uma barra de abas no mobile. Um usuário mobile terá uma aba ativa, mas esse conceito não tem equivalente no desktop. Armazenar o índice da aba ativa dentro de um StatefulWidget (uma decisão idiomática em Flutter!) faria a posição do usuário mobile voltar sempre para a aba padrão depois de alternar de um lado para outro pela UI de desktop. A solução para isso envolve mover qualquer estado primitivo da aplicação — strings, inteiros e afins — para fora dos StatefulWidgets e para dentro das suas classes de gerenciamento de estado. Assim, nenhuma gambiarra na árvore de widgets consegue redefinir valores críticos.

A segunda camada do problema vem de um estado da aplicação mais difícil de tirar da árvore de widgets, como TextEditingControllers ou ScrollControllers. A situação é esta: você tem um ListTile com um TextField, mas sempre que o usuário toca com o mouse ou com a tela sensível ao toque, você reconstrói esse ListTile para acomodar os periféricos mais recentes do usuário. Sem intervenção, isso faria o Flutter destruir toda a parte das árvores de Widgets e Elements que contém o TextField antigo, levando junto quaisquer controllers que guardam o trabalho do usuário. Você pode ser tentado a tratar isso como primitivos (TextEditingControllers como strings e ScrollControllers como doubles) e repetir a solução acima; mas os controllers são ricos demais para serializar dessa forma com facilidade (posição do cursor e seleção de texto, alguém?).

Para resolver esse problema, o Google Earth usa GlobalKeys para fazer o framework “reparentar” widgets de escopo restrito depois de um novo layout. O AdaptableTextInput a seguir está fortemente restrito ao seu TextField e ao seu TextEditingController. Fornecer a mesma GlobalKey ao widget AdaptableTextInput entre as reconstruções que mudam a UI manterá o TextEditingController vivo, preservando o trabalho dos seus usuários.

dart
class AdaptableTextInput extends StatefulWidget {
​
  // Supply a consistent GlobalKey here!
  const AdaptableTextInput({super.key, required this.mode});
​
  final Mode mode;
​
  @override
  State<AdaptableTextInput> createState() => _AdaptableTextInputState();
}
​
class _AdaptableTextInputState extends State<AdaptableTextInput> {
​
  final _controller = TextEditingController();
  final String helpText = 'I clarify this text input!';
​
  @override
  Widget build(BuildContext context) {
    if (widget.mode == Mode.desktop) {
      return Tooltip(
        showOnHover: helpText,
        child: TextField(controller: _controller),
      );
    } else if (widget.mode == Mode.mobile) {
      return Column(
        children: <Widget>[
          TextField(controller: _controller),
          Text(helpText);
        ],
      );
    }
  }
}

As pilhas de navegação e o botão Voltar do app também exigem atenção especial. Continuando com o exemplo acima de uma UI de desktop que mostra vários painéis ao mesmo tempo, agora imagine uma UI mobile complementar que apresenta esses painéis em uma pilha, com navegação para frente e para trás. As implicações de permitir que desktops usem a UI mobile e que celulares usem a UI de desktop foram uma das grandes ideias de adaptabilidade que o Google Earth queria explorar.

Uma grade de UIs, mostrando a UI de desktop tanto em dispositivos desktop quanto mobile, e a UI mobile tanto em dispositivos desktop quanto mobile
Uma grade de UIs, mostrando a UI de desktop tanto em dispositivos desktop quanto mobile, e a UI mobile tanto em dispositivos desktop quanto mobile

Se um usuário da UI de desktop estiver no painel vermelho quando alternar para a UI mobile, o botão Voltar não será configurado automaticamente, porque a pilha de navegação será redefinida. Isso significa que a sua UI de desktop precisa considerar informações extras que tecnicamente só a UI mobile precisaria, porque a qualquer momento a UI mobile pode ser chamada para assumir.

Um dispositivo desktop renderizando a mesma UI em dois modos diferentes — um típico de desktop e outro típico de mobile
Um dispositivo desktop renderizando a mesma UI em dois modos diferentes — um típico de desktop e outro típico de mobile

Felizmente, a API declarativa de rotas do GoRouter pode ajudar. Crie duas declarações de rota separadas e mude para a rota apropriada quando o usuário alternar os modos de UI. Nessa situação, se a UI de desktop tiver registrado a última atividade do usuário no painel vermelho quando chegar um pedido para ativar a UI mobile, chamar mobileRouter.go('home/blue/red') vai criar uma pilha de navegação com um histórico sintético, permitindo que o usuário pressione o botão Voltar para sair da tela vermelha.

dart
final desktopRouter = GoRouter(
  routes: [
    GoRoute(
      path: '/home',
      builder: (context, state) => FourPanels(),
    ),
  ],
);
​
final mobileRouter = GoRouter(
  routes: [
    // One route for each panel, configured to wire up
    // the Back button if a user arrives on one of the nested panels
    GoRoute(
      path: '/home/blue',
      builder: (context, state) => BluePanel(),
      routes: [
        GoRoute(
          path: 'red',
          builder: (context, state) => RedPanel(),
          routes: [
            GoRoute(
              path: 'green',
              builder: (context, state) => GreenPanel(),
              routes: [
                GoRoute(
                  path: 'yellow',
                  builder: (context, state) => YellowPanel(),
                ),
              ],
            ),
          ],
        ),
      ],
    ),
  ],
);

UIs altamente adaptativas como a do Google Earth exigem uma implementação que trate todos os cenários possíveis como sempre em jogo, mesmo que apenas uma UI esteja sendo renderizada em cada momento. Isso significa que o app precisa sempre conseguir reconstruir por completo seu estado a partir de recursos que você controla totalmente — seja porque você tem GlobalKeys para reter objetos State que guardam informações importantes, seja porque armazenou todos os detalhes relevantes nas suas classes de gerenciamento de estado.

Adaptando-se às entradas do usuário

Tudo isso deixou apenas mais um problema de adaptabilidade complicado: garantir que os controles da UI fossem compatíveis com os últimos periféricos usados pelo usuário, e não apenas com a estratégia de UI vigente. Afinal, se um usuário de tablet começasse a clicar com um mouse Bluetooth, o Google Earth não ia trocar por completo para a UI de desktop, mas o usuário queria ajustar levemente alguns elementos para aproveitar os pontos fortes do teclado e do mouse.

Só o uso do Flutter já deu ao Google Earth um bom começo nesse ponto. Imagine a alternativa: um app dividido em três codebases (JavaScript para desktop via web, e Swift e Kotlin para mobile), quando as equipes de Swift e Kotlin percebem que seria bem útil, em alguns cenários, poder aproveitar elementos da UI do app em JavaScript. Talvez o que elas precisam possa ser reimplementado de forma simples o bastante; ou talvez não. De qualquer forma, em um app Flutter, a ferramenta existente que você quer reaproveitar está sempre no mesmo codebase.

Mas compartilhar código não é organização de código, e a questão de como implementar isso de forma coerente continuou em aberto. Aqui, a equipe do Google Earth recorreu a um velho clássico do Flutter: o padrão builder.

dart
/// High level categories of user inputs.
enum InputType { gamepad, keyboardAndMouse, touch }
​
/// Builds a widget tree that depends on the user's current [InputType].
class InputTypeBuilder extends StatelessWidget {
  /// Called when the [InputType] data updates.
  final Function(BuildContext, InputTypeModel, Widget?) builder;
​
  /// Constructs a wrapping widget that will invoke the [builder] whenever
  /// [InputType] changes.
  ///
  /// See [InputTypeModel] for details on how to change [InputType].
  const InputTypeBuilder({
    Key? key,
    required this.builder,
  }) : super(key: key);
​
  @override
  Widget build(BuildContext context) {
    return Consumer<InputTypeModel>(
      builder: (context, inputTypeModel, _) {
        return builder(
          context,
          inputTypeModel.inputType,
        );
      },
    );
  }
}

Um widget como InputTypeBuilder escuta um mecanismo de nível superior, o InputTypeModel, que por sua vez se inscreve na Flutter Engine para receber atualizações sobre a última entrada usada. InputTypeModel.inputType é uma propriedade do enum InputType. Com isso, widgets filhos podem tomar decisões locais sobre como se renderizar à luz de como o usuário está interagindo com o app no momento. Por exemplo, se você estava usando o mouse, mas depois tocou a tela com o dedo, os elementos de interação que antes só apareciam com o efeito de hover do cursor passariam a aparecer em todo o app. E, da mesma forma, se você voltasse a usar o mouse, este InputTypeBuilder permitiria reverter a mudança.

dart
@override
Widget build(BuildContext context) {
  return InputTypeBuilder(
    builder: (context, inputTypeModel, child) {
      final bool isHoveredOrTouchInput = isHovered || inputTypeModel.inputType == InputType.touch;
      return Row(
        children: <Widget>[
          isHoveredOrTouchInput ? DragIndicator() : Container(),
          RestOfRow(),
        ],
      );
    },
  );
}

O gif a seguir mostra a UI de desktop do Google Earth (rodando no Chrome), ajustando-se com agilidade conforme o usuário alterna entre ações na tela sensível ao toque e no mouse.

A UI do Google Earth alternando entre elementos típicos de desktop e de mobile conforme o usuário interage com diferentes periféricos
A UI do Google Earth alternando entre elementos típicos de desktop e de mobile conforme o usuário interage com diferentes periféricos

Conclusão

Os maiores ganhos inesperados ao reconstruir o Google Earth com Flutter foram para os usuários de ambientes intermediários — tablets e web. Presos de forma incômoda entre celulares e notebooks, os tablets fisicamente conseguem suportar os dois tipos de experiência, mas raramente têm a flexibilidade de software para acompanhar. Da mesma forma, experiências web podem ser carregadas em qualquer dispositivo; e, no desktop, navegadores podem ser redimensionados arbitrariamente. Dependendo do app, tudo isso pode implicar UIs radicalmente diferentes. Para a maioria das equipes de desenvolvimento, com codebases separadas para cada plataforma alvo, dar suporte completo a usuários presos nesses estados intermediários é inviável. (Imagine convencer seu chefe a gastar tempo reconstruindo toda a UI de desktop no mobile, só para o caso de um usuário de tablet querer!)

Mas, como a equipe do Google Earth descobriu, embora construir uma UI totalmente adaptativa em um único codebase implicasse complexidade extra, essa complexidade foi ofuscada pelas melhorias de experiência do usuário obtidas ao encontrar cada usuário exatamente onde ele estava.

Você pode testar a nova implementação em Flutter do Google Earth hoje mesmo, baixando o app no Android ou no iOS, ou acessando https://earth.google.com.

Mais do Flutter