O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Otimizar mostradores de relógio

Um mostrador do relógio do Wear OS é executado continuamente e, portanto, precisa usar a energia de maneira eficiente.

Além disso, o desempenho do mostrador do relógio deve ser otimizado. Os serviços não podem realizar cálculos desnecessários. Os mostradores de relógio com animações precisam ser executados sem problemas, ao mesmo tempo em que acomodam notificações e indicadores do sistema.

Otimização básica

Esta seção contém as práticas recomendadas para melhorar a eficiência.

Cor e brilho do mostrador do relógio

Cores escuras preservam a bateria do relógio. Veja a seguir recomendações para configurar o plano de fundo do mostrador do relógio para otimizar o uso da bateria:

  • Cor: sempre que possível, use um plano de fundo preto.
  • Brilho: quando os requisitos do mostrador do relógio impedem o uso de um plano de fundo preto, faça o possível para manter o brilho da cor de fundo igual ou menor que 25% em uma escala de matiz, saturação e valor (HSV, na sigla em inglês) ou HSB. Por exemplo, se você usar a classe Color para definir a cor do plano de fundo e definir a cor com a escala HSV, usará 25 ou menos para a configuração "Valor", ou seja, para a configuração de brilho.

Usar callbacks no WatchFaceService.Engine

Verifique se o mostrador do relógio realiza cálculos apenas quando está ativo. Use callbacks em WatchFaceService.Engine. De preferência, use os seguintes métodos dessa classe para determinar se o mostrador do relógio está visível:

  • onVisibilityChanged(boolean)
  • isVisible()

Como alternativa, use os seguintes métodos da mesma classe (WatchFaceService.Engine).

  • onCreate()
  • onDestroy()

Usar listeners registrados com a interface DataClient

Para ouvir eventos, use os listeners em tempo real registrados com DataClient.addListener. Por exemplo, consulte Sincronizar itens de dados.

Não use WearableListenerService para ouvir eventos, uma vez que ele é chamado independentemente de o mostrador do relógio estar ou não ativo. Para mais informações, consulte Suspensão de uso de BIND_LISTENER.

Não registre um broadcast receiver no arquivo de manifesto do Android para acessar eventos do sistema, como mudanças de fuso horário, eventos de bateria etc. O BroadcastReceiver é chamado independentemente de o mostrador do relógio estar ou não ativo. No entanto, você pode usar o método registerReceiver da classe Context para registrar um receptor.

Usar recursos dinâmicos para interagir com o smartphone

Quando o mostrador do relógio exige a execução de uma operação no smartphone, esse código só deve ser executado quando o mostrador do relógio está ativo. O método recomendado para permitir que o app no smartphone saiba que o mostrador do relógio correspondente está ativo é usar a API CapabilityClient.

Defina um recurso que seja adicionado dinamicamente ao método onCreate() de WatchFaceService.Engine. Remova o recurso com o método onDestroy().

Por exemplo, um app que busca dados periódicos para exibir no mostrador do relógio deve registrar um listener para os recursos anunciados pelo mostrador. Adicione um alarme para buscar dados atualizados e enviá-los para o mostrador do relógio quando estiver acessível. Remova o alarme periódico se o mostrador do relógio não estiver mais selecionado ou se o relógio estiver fora de alcance, estiver desligado ou não conseguir receber as atualizações.

Monitorar o consumo de energia

O app associado do Wear OS permite que os desenvolvedores e usuários vejam a quantidade de bateria consumida por diferentes processos no dispositivo wearable (em Configurações > Bateria do relógio).

Para informações sobre os recursos introduzidos no Android 5.0 que ajudam a melhorar a duração da bateria, consulte Projeto Volta.

Registrar mostradores do relógio com reconhecimento de criptografia

O Android 7.0 e versões mais recentes são compatíveis com criptografia baseada em arquivo e permitem que aplicativos com reconhecimento de criptografia sejam executados antes de o usuário informar a senha de descriptografia durante a inicialização. Isso pode diminuir o tempo da transição da animação de inicialização para o mostrador do relógio em até 30 segundos.

Para permitir uma inicialização mais rápida, adicione android:directBootAware="true" ao manifesto do mostrador do relógio.

Observação: use esse recurso com mostradores de relógio que não usam armazenamento criptografado por credencial.

Práticas recomendadas para animações

As práticas recomendadas desta seção ajudam a reduzir o consumo de energia das animações.

Reduzir a frame rate das animações

Em geral, as animações utilizam recursos computacionais dispendiosos e consomem uma quantidade significativa de energia. A maioria das animações apresenta fluidez a 30 quadros por segundo. Assim, evite executá-las com uma frame rate mais alta. Você pode controlar a frame rate quando invalidate() é usado no final do método draw() adicionando um atraso antes de chamar o método invalidate(). Veja como implementar essa etapa em Desenhar mostradores de relógio.

Colocar a CPU no modo de suspensão entre as animações

Animações e pequenas mudanças no conteúdo do mostrador do relógio ativam a CPU. O mostrador do relógio precisa permitir que a CPU entre no modo de suspensão entre as animações. Por exemplo, você pode usar sequências curtas de animação a cada segundo no modo interativo e deixar a CPU em suspensão até o segundo seguinte. Colocar a CPU em suspensão com frequência, mesmo que por breves instantes, pode reduzir significativamente o consumo de energia.

Para maximizar a duração da bateria, use animações com moderação. Até mesmo um ponto piscando ativa a CPU a cada piscada e prejudica a duração da bateria.

Reduzir o tamanho dos recursos de bitmap

Muitos mostradores de relógio consistem em uma imagem de plano de fundo e outros recursos gráficos que são transformados e sobrepostos na parte superior da imagem de plano de fundo, como os ponteiros do relógio e outros elementos do desenho que se movem com o tempo. Normalmente, esses elementos gráficos são girados (e, às vezes, redimensionados) dentro do método Engine.onDraw() toda vez que o sistema redesenha o mostrador do relógio, conforme descrito em Desenhar o mostrador do relógio.

Quanto maiores esses recursos gráficos, mais recursos computacionais dispendiosos serão necessários para transformá-los. A transformação de recursos gráficos grandes no método Engine.onDraw() reduz drasticamente a frame rate em que o sistema pode executar as animações.

Figura 1. Os ponteiros do relógio podem ser cortados para remover pixels extras.

Para melhorar o desempenho do mostrador do relógio:

  • Não use elementos gráficos maiores do que o necessário.
  • Remova pixels extras transparentes ao redor das bordas.

O ponteiro do relógio do exemplo no lado esquerdo da Figura 1 pode ter o tamanho reduzido em 97%.

A redução do tamanho dos recursos de bitmap, conforme descrito nesta seção, não apenas melhora o desempenho das animações, mas também economiza energia.

Combinar recursos de bitmap

Se você tem bitmaps que geralmente são desenhados juntos, combine-os no mesmo recurso gráfico. Muitas vezes, é possível combinar a imagem de plano de fundo no modo interativo com as marcas de verificação para não ter que desenhar dois bitmaps de tela inteira sempre que o sistema redesenha o mostrador.

Desativar a suavização ao desenhar bitmaps dimensionados

Quando você desenha um bitmap dimensionado no objeto Canvas usando o método Canvas.drawBitmap(), é possível informar uma instância de Paint para configurar várias opções. Para melhorar o desempenho, desative a suavização usando o método setAntiAlias(), já que essa opção não tem nenhum efeito nos bitmaps.

Figura 2. Exemplo de filtro de bitmap desativado (à esquerda) e ativado (à direita).

Usar filtragem de bitmap

Para recursos de bitmap que você desenha sobre outros elementos, ative a filtragem de bitmap na mesma instância de Paint usando o método setFilterBitmap(). A Figura 2 mostra uma visualização ampliada de um ponteiro de relógio com e sem filtragem de bitmap.

Observação: no modo ambiente de poucos bits, o sistema não renderiza corretamente as cores na imagem, o que não permite a realização da filtragem de bitmap. Quando o modo ambiente estiver ativo, desative a filtragem de bitmap.

Eliminar operações dispendiosas do método de desenho

O sistema chama o método Engine.onDraw() sempre que redesenha o mostrador do relógio. Portanto, inclua somente as operações estritamente necessárias para atualizar o mostrador do relógio dentro desse método para melhorar o desempenho.

Quando possível, evite realizar essas operações dentro do método Engine.onDraw():

  • Carregar imagens e outros recursos
  • Redimensionar imagens
  • Alocar objetos
  • Realizar cálculos cujo resultado não muda entre os quadros

Normalmente, é possível realizar essas operações no método Engine.onCreate(). Você pode redimensionar as imagens antecipadamente no método Engine.onSurfaceChanged(), que informa você sobre o tamanho da tela.

Para analisar o desempenho do mostrador do relógio, use o Criador de perfil da CPU. Em particular, o tempo de execução da implementação do Engine.onDraw() precisa ser curto e consistente em todas as invocações. Para saber mais, consulte Gravar e inspecionar rastreamentos de método.