Como criar experiências em tela cheia

Temos a capacidade de criar facilmente sites e aplicativos imersivos em tela cheia, mas, como tudo na Web, há algumas maneiras de fazer isso. Isso é especialmente importante agora que mais navegadores oferecem suporte a uma experiência de "app da Web instalado" que é iniciada em tela cheia.

Como abrir o app ou site em tela cheia

Há várias maneiras de um usuário ou desenvolvedor colocar um app da Web em tela cheia.

  • Solicite que o navegador entre em tela cheia em resposta a uma interação inicial.
  • Instale o app na tela inicial.
  • Simule: oculte automaticamente a barra de endereço.

Solicitar que o navegador entre no modo de tela cheia em resposta a uma interação inicial

Nem todas as plataformas são iguais. O Safari para iOS não tem uma API de tela cheia, mas o Chrome para Android, o Firefox e o IE 11+ têm. A maioria dos aplicativos que você criar vai usar uma combinação da API JS e dos seletores de CSS fornecidos pela especificação de tela cheia. As principais APIs JS que você precisa considerar ao criar uma experiência em tela cheia são:

  • element.requestFullscreen() (atualmente prefixado no Chrome, Firefox e IE) mostra o elemento no modo de tela cheia.
  • document.exitFullscreen() (atualmente prefixado no Chrome, Firefox e IE. O Firefox usa cancelFullScreen()) cancela o modo de tela cheia.
  • document.fullscreenElement (atualmente prefixado no Chrome, Firefox e IE) retorna verdadeiro se algum dos elementos estiver no modo de tela cheia.

Quando o app está em tela cheia, os controles de interface do navegador não estão mais disponíveis. Isso muda a forma como os usuários interagem com sua experiência. Eles não têm os controles de navegação padrão, como "Avançar" e "Voltar", nem o botão "Atualizar", que é uma saída de emergência. É importante atender a esse cenário. Você pode usar alguns seletores de CSS para mudar o estilo e a apresentação do site quando o navegador entra no modo de tela cheia.

<button id="goFS">Go fullscreen</button>
<script>
  var goFS = document.getElementById('goFS');
  goFS.addEventListener(
    'click',
    function () {
      document.body.requestFullscreen();
    },
    false,
  );
</script>

O exemplo acima é um pouco artificial. Ocultamos toda a complexidade em torno do uso de prefixos de fornecedor.

O código real é muito mais complexo. A Mozilla criou um script muito útil que pode ser usado para alternar para o modo de tela cheia. Como você pode ver, a situação do prefixo do fornecedor é complexa e complicada em comparação com a API especificada. Mesmo com o código um pouco simplificado abaixo, ele ainda é complexo.

function toggleFullScreen() {
  var doc = window.document;
  var docEl = doc.documentElement;

  var requestFullScreen =
    docEl.requestFullscreen ||
    docEl.mozRequestFullScreen ||
    docEl.webkitRequestFullScreen ||
    docEl.msRequestFullscreen;
  var cancelFullScreen =
    doc.exitFullscreen ||
    doc.mozCancelFullScreen ||
    doc.webkitExitFullscreen ||
    doc.msExitFullscreen;

  if (
    !doc.fullscreenElement &&
    !doc.mozFullScreenElement &&
    !doc.webkitFullscreenElement &&
    !doc.msFullscreenElement
  ) {
    requestFullScreen.call(docEl);
  } else {
    cancelFullScreen.call(doc);
  }
}

Nós, desenvolvedores web, odiamos a complexidade. Uma boa API abstrata de alto nível que você pode usar é o módulo Screenfull.js de Sindre Sorhus, que unifica as duas APIs JS ligeiramente diferentes e os prefixos de fornecedor em uma API consistente.

Dicas da API Fullscreen

Abrindo o documento em tela cheia
Tela cheia no elemento body
Figura 1: tela cheia no elemento do corpo.

É natural pensar que você coloca o elemento body em tela cheia, mas se você estiver em um mecanismo de renderização baseado em WebKit ou Blink, verá que ele tem um efeito estranho de reduzir a largura do corpo para o menor tamanho possível que conterá todo o conteúdo. (Mozilla Gecko é aceitável.)

Tela cheia no elemento do documento
Figura 2: tela cheia no elemento do documento.

Para corrigir isso, use o elemento document em vez do elemento body:

document.documentElement.requestFullscreen();
Como abrir um elemento de vídeo em tela cheia

Para colocar um elemento de vídeo em tela cheia, o processo é exatamente o mesmo que para qualquer outro elemento. Chame o método requestFullscreen no elemento de vídeo.

<video id="videoElement"></video>
<button id="goFS">Go Fullscreen</button>
<script>
  var goFS = document.getElementById('goFS');
  goFS.addEventListener(
    'click',
    function () {
      var videoElement = document.getElementById('videoElement');
      videoElement.requestFullscreen();
    },
    false,
  );
</script>

Se o elemento <video> não tiver o atributo de controles definido, não será possível controlar o vídeo quando ele estiver em tela cheia. A maneira recomendada de fazer isso é ter um contêiner básico que envolva o vídeo e os controles que você quer que o usuário veja.

<div id="container">
  <video></video>
  <div>
    <button>Play</button>
    <button>Stop</button>
    <button id="goFS">Go fullscreen</button>
  </div>
</div>
<script>
  var goFS = document.getElementById('goFS');
  goFS.addEventListener(
    'click',
    function () {
      var container = document.getElementById('container');
      container.requestFullscreen();
    },
    false,
  );
</script>

Isso oferece muito mais flexibilidade, porque você pode combinar o objeto de contêiner com o pseudosseletor de CSS (por exemplo, para ocultar o botão "goFS").

<style>
  #goFS:-webkit-full-screen #goFS {
    display: none;
  }
  #goFS:-moz-full-screen #goFS {
    display: none;
  }
  #goFS:-ms-fullscreen #goFS {
    display: none;
  }
  #goFS:fullscreen #goFS {
    display: none;
  }
</style>

Usando esses padrões, é possível detectar quando o modo de tela cheia está em execução e adaptar a interface do usuário de forma adequada, por exemplo:

  • Fornecendo um link para voltar à página inicial
  • Oferecendo um mecanismo para fechar caixas de diálogo ou voltar

Iniciar uma página em tela cheia na tela inicial

Não é possível iniciar uma página da Web em tela cheia quando o usuário navega até ela. Os fornecedores de navegadores sabem que uma experiência em tela cheia em cada carregamento de página é um grande incômodo. Por isso, é necessária uma interação do usuário para entrar em tela cheia. No entanto, os fornecedores permitem que os usuários "instalem" apps, e o ato de instalar é um sinal para o sistema operacional de que o usuário quer iniciar como um app na plataforma.

Nas principais plataformas para dispositivos móveis, é muito fácil implementar usando metatags ou arquivos de manifesto, como mostrado abaixo.

iOS

Desde o lançamento do iPhone, os usuários podem instalar apps da Web na tela inicial e iniciá-los como apps da Web em tela cheia.

<meta name="apple-mobile-web-app-capable" content="yes" />

Se o conteúdo for definido como "yes", o aplicativo da Web será executado no modo de tela cheia. Caso contrário, não. O comportamento padrão é usar o Safari para exibir conteúdo da Web. É possível determinar se uma página da Web é exibida no modo de tela cheia usando a propriedade booleana somente leitura do JavaScript window.navigator.standalone.

Apple

Google Chrome para Android

A equipe do Chrome implementou recentemente um recurso que instrui o navegador a abrir a página em tela cheia quando o usuário a adiciona à tela inicial. Ele é semelhante ao modelo do Safari para iOS.

<meta name="mobile-web-app-capable" content="yes" />

É possível configurar seu app da Web para que um ícone de atalho seja adicionado à tela inicial de um dispositivo e para que o app seja iniciado no "modo de app" em tela cheia usando o item de menu "Adicionar à tela inicial" do Google Chrome para Android.

Google Chrome

Uma opção melhor é usar o manifesto do app da Web.

Manifesto do app da Web (Chrome, Opera, Firefox, Samsung)

O Manifesto para aplicativos da Web é um arquivo JSON simples que permite que você, o desenvolvedor, controle como seu app aparece para o usuário nas áreas em que ele espera ver apps (por exemplo, a tela inicial do dispositivo móvel), direcione o que o usuário pode iniciar e, mais importante, como ele pode iniciar. No futuro, o manifesto vai oferecer ainda mais controle sobre o app, mas, por enquanto, estamos nos concentrando apenas em como o app pode ser iniciado. Especificamente:

  1. Como informar o navegador sobre seu manifesto
  2. Descrever como iniciar

Depois de criar o manifesto e hospedá-lo no seu site, basta adicionar uma tag de link de todas as páginas que abrangem o app, da seguinte forma:

<link rel="manifest" href="/manifest.json" />

O Chrome é compatível com manifestos desde a versão 38 para Android (outubro de 2014) e oferece controle sobre como o app da Web aparece quando é instalado na tela inicial (pelas propriedades short_name, name e icons) e como ele deve ser iniciado quando o usuário clica no ícone de inicialização (pelas propriedades start_url, display e orientation).

Confira um exemplo de manifesto abaixo. Ele não mostra tudo o que pode estar em um manifesto.

{
  "short_name": "Kinlan's Amaze App",
  "name": "Kinlan's Amazing Application ++",
  "icons": [
    {
      "src": "launcher-icon-4x.png",
      "sizes": "192x192",
      "type": "image/png"
    }
  ],
  "start_url": "/index.html",
  "display": "standalone",
  "orientation": "landscape"
}

Esse recurso é totalmente progressivo e permite criar experiências melhores e mais integradas para usuários de um navegador que oferece suporte ao recurso.

Quando um usuário adiciona seu site ou app à tela inicial, ele pretende usá-lo como um app. Isso significa que você deve direcionar o usuário para a funcionalidade do seu app, em vez de uma página de destino do produto. Por exemplo, se o usuário precisar fazer login no app, essa é uma boa página para iniciar.

Apps utilitários

A maioria dos apps utilitários vai se beneficiar disso imediatamente. Para esses apps, é provável que você queira que eles sejam iniciados de forma independente, como qualquer outro app em uma plataforma móvel. Para que um app seja iniciado de forma independente, adicione o seguinte ao manifesto do app da Web:

    "display": "standalone"
Jogos

A maioria dos jogos vai se beneficiar de um manifesto imediatamente. A grande maioria dos jogos é iniciada em tela cheia e força uma orientação específica.

Se você estiver desenvolvendo um jogo de rolagem vertical ou um jogo como Flappy Birds, provavelmente vai querer que ele esteja sempre no modo retrato.

    "display": "fullscreen",
    "orientation": "portrait"

Por outro lado, se você estiver criando um jogo de quebra-cabeça ou um jogo como X-Com, provavelmente vai querer que o jogo use sempre a orientação paisagem.

    "display": "fullscreen",
    "orientation": "landscape"
Sites de notícias

Na maioria dos casos, os sites de notícias são experiências puramente baseadas em conteúdo. A maioria dos desenvolvedores não pensaria em adicionar um manifesto a um site de notícias. O manifesto permite definir o que iniciar (a página inicial do seu site de notícias) e como iniciar (em tela cheia ou como uma guia normal do navegador).

A escolha é sua e depende de como você acha que os usuários vão gostar de acessar sua experiência. Se você quiser que seu site tenha todos os elementos de interface do navegador que um site normalmente tem, defina a exibição como browser.

    "display": "browser"

Se você quiser que seu site de notícias se pareça com a maioria dos apps de notícias, trate as experiências como apps e remova todo o Chrome da IU. Para isso, defina a exibição como standalone.

    "display": "standalone"

Simular: ocultar automaticamente a barra de endereço

É possível "simular a tela cheia" ocultando automaticamente a barra de endereço da seguinte maneira:

window.scrollTo(0, 1);

Esse é um método bem simples: a página é carregada e a barra do navegador é instruída a sair do caminho. Infelizmente, ele não é padronizado e não tem um bom suporte. Você também precisa lidar com várias peculiaridades.

Por exemplo, os navegadores geralmente restauram a posição na página quando o usuário volta para ela. O uso de window.scrollTo substitui isso, o que incomoda o usuário. Para contornar isso, é necessário armazenar a última posição em localStorage e lidar com os casos extremos (por exemplo, se o usuário tiver a página aberta em várias janelas).

Orientações de UX

Ao criar um site que aproveita a tela cheia, há várias possíveis mudanças na experiência do usuário que você precisa conhecer para criar um serviço que os usuários vão adorar.

Não dependa dos controles de navegação

O iOS não tem um botão "Voltar" de hardware nem um gesto de atualização. Portanto, é preciso garantir que os usuários possam navegar pelo app sem ficar presos.

É possível detectar se você está executando em um modo de tela cheia ou instalado com facilidade em todas as principais plataformas.

iOS

No iOS, use o booleano navigator.standalone para conferir se o usuário iniciou o app na tela inicial.

if (navigator.standalone == true) {
  // My app is installed and therefore fullscreen
}

Manifesto do app da Web (Chrome, Opera, Samsung)

Ao ser iniciado como um app instalado, o Chrome não é executado em uma experiência de tela cheia verdadeira. Portanto, document.fullscreenElement retorna nulo, e os seletores de CSS não funcionam.

Quando o usuário solicita o modo de tela cheia por um gesto no seu site, as APIs padrão de tela cheia ficam disponíveis, incluindo o pseudoseletor CSS que permite adaptar a interface para reagir ao estado de tela cheia, como o seguinte:

selector:-webkit-full-screen {
  display: block; // displays the element only when in fullscreen
}

selector {
  display: none; // hides the element when not in fullscreen mode
}

Se os usuários iniciarem o site na tela inicial, a consulta de mídia display-mode será definida de acordo com o que foi definido no manifesto do app da Web. No caso de tela cheia pura, será:

@media (display-mode: fullscreen) {
}

Se o usuário iniciar o aplicativo no modo independente, a consulta de mídia display-mode será standalone:

@media (display-mode: standalone) {
}

Firefox

Quando o usuário solicita o modo de tela cheia pelo site ou inicia o app nesse modo, todas as APIs padrão de tela cheia ficam disponíveis, incluindo o pseudosseletor de CSS, que permite adaptar a interface para reagir ao estado de tela cheia, como este:

selector:-moz-full-screen {
  display: block; // hides the element when not in fullscreen mode
}

selector {
  display: none; // hides the element when not in fullscreen mode
}

Internet Explorer

No IE, a pseudoclasse CSS não tem um hífen, mas funciona de maneira semelhante ao Chrome e ao Firefox.

selector:-ms-fullscreen {
  display: block;
}

selector {
  display: none; // hides the element when not in fullscreen mode
}

Especificação

A ortografia na especificação corresponde à sintaxe usada pelo IE.

selector:fullscreen {
  display: block;
}

selector {
  display: none; // hides the element when not in fullscreen mode
}

Manter o usuário na experiência em tela cheia

A API de tela cheia pode ser um pouco complicada às vezes. Os fornecedores de navegadores não querem bloquear os usuários em uma página em tela cheia. Por isso, eles desenvolveram mecanismos para sair da tela cheia assim que possível. Isso significa que não é possível criar um site em tela cheia que abranja várias páginas porque:

  • Mudar o URL de forma programática usando window.location = "http://example.com" interrompe o modo de tela cheia.
  • Se um usuário clicar em um link externo na sua página, ele vai sair do modo de tela cheia.
  • Mudar o URL usando a API navigator.pushState também vai interromper a experiência de tela cheia.

Você tem duas opções se quiser manter o usuário em uma experiência de tela cheia:

  1. Use os mecanismos de apps da Web instaláveis para entrar no modo de tela cheia.
  2. Gerencie o estado da interface e do app usando o fragmento #.

Ao usar a #syntax para atualizar o URL (window.location = "#somestate") e detectar o evento window.onhashchange, é possível usar a própria pilha de histórico do navegador para gerenciar mudanças no estado do aplicativo, permitir que o usuário use os botões "Voltar" do hardware ou oferecer uma experiência simples de botão "Voltar" programático usando a API History da seguinte maneira:

window.history.go(-1);

Permitir que o usuário escolha quando entrar no modo de tela cheia

Não há nada mais irritante para o usuário do que um site que faz algo inesperado. Quando um usuário navegar até seu site, não tente enganá-lo para que ele entre no modo de tela cheia.

Não intercepte o primeiro evento de toque e chame requestFullscreen().

  1. É irritante.
  2. Os navegadores podem decidir perguntar ao usuário em algum momento no futuro se o app pode ocupar a tela cheia.

Se você quiser iniciar apps em tela cheia, use as experiências de instalação para cada plataforma.

Não envie spam para o usuário instalar o app em uma tela inicial

Se você planeja oferecer uma experiência em tela cheia usando os mecanismos de apps instalados, pense no usuário.

  • Seja discreto. Use um banner ou rodapé para informar que eles podem instalar o app.
  • Se o usuário dispensar a solicitação, não a mostre novamente.
  • Na primeira visita, é improvável que os usuários queiram instalar o app, a menos que estejam satisfeitos com seu serviço. Considere pedir que eles instalem o app após uma interação positiva no seu site.
  • Se um usuário visita seu site regularmente e não instala o app, é improvável que ele faça isso no futuro. Não envie spam para eles.

Conclusão

Embora não tenhamos uma API totalmente padronizada e implementada, usando algumas das orientações apresentadas neste artigo, você pode criar facilmente experiências que aproveitam toda a tela do usuário, independentemente do cliente.

Feedback