Manter o dispositivo ativo

Para evitar o consumo da bateria, um dispositivo Android que fica ocioso cai rapidamente adormecidos. No entanto, há momentos em que um aplicativo precisa ativar a tela ou a CPU e mantê-lo ativo para concluir algum trabalho.

A abordagem adotada depende das necessidades do seu app. No entanto, uma regra geral é que você deve usar a abordagem mais leve possível para seu para minimizar o impacto do seu aplicativo nos recursos do sistema. As seções a seguir descrever como lidar com os casos em que o comportamento de suspensão padrão do dispositivo é incompatível com os requisitos do seu app.

Alternativas ao uso de wake locks

Antes de adicionar suporte a wake locks, considere se o uso do seu app os casos são compatíveis com uma das seguintes soluções alternativas:

• Se o app estiver realizando downloads HTTP de longa duração, considere usar DownloadManager

• Se seu aplicativo estiver sincronizando dados de um servidor externo, considere criar um adaptador de sincronização.

• Caso seu app dependa de serviços em segundo plano, considere usar JobScheduler ou Firebase Cloud Messaging para acionar esses serviços em intervalos específicos.

• Se você precisar manter seu app complementar em execução sempre que houver um dispositivo complementar ao alcance, use o Gerenciador de dispositivos complementar.

Manter a tela ativada

Alguns apps precisam manter a tela ativada, por exemplo, os apps de jogos ou filmes. A a melhor maneira de fazer isso é usando o FLAG_KEEP_SCREEN_ON na sua atividade (e somente em uma atividade, nunca em um serviço ou outro aplicativo ). Exemplo:

class MainActivity : Activity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
    }
}

public class MainActivity extends Activity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  }
}

A vantagem dessa abordagem é que, ao contrário dos wake locks (discutidos em Manter a CPU ativada), ela não requer permissão especial, e a plataforma gerencia corretamente o usuário que se move entre aplicativos, sem que o aplicativo precise se preocupar com a liberação de recursos não utilizados.

Outra forma de implementar isso é no arquivo XML de layout do seu aplicativo, usando o atributo android:keepScreenOn:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:keepScreenOn="true">
    ...
</RelativeLayout>

Usar android:keepScreenOn="true" é equivalente a usar FLAG_KEEP_SCREEN_ON. Use a abordagem que for melhor para seu app. A vantagem de definir a sinalização de maneira programática em sua atividade é que ela oferece a opção de limpar programaticamente o sinalizador mais tarde e, assim, permitir que a tela gire

Modo ambiente para TV

Na TV, FLAG_KEEP_SCREEN_ON deve ser usado para evitar que o dispositivo entre Modo ambiente durante a reprodução de vídeo ativa. Quando FLAG_KEEP_SCREEN_ON não estiver definido pela atividade em primeiro plano, o dispositivo entrará automaticamente no Modo ambiente. após um período de inatividade.

Manter a CPU ligada

Se você precisar manter a CPU em execução para concluir algum trabalho antes que o dispositivo entrar em modo de suspensão, você poderá usar Recurso de serviço do sistema do PowerManager chamados de wake locks. Os wake locks permitem que seu aplicativo controle o estado da energia do dispositivo host.

Criar e manter wake locks pode causar um grande impacto no sistema host duração da bateria. Portanto, você deve usar wake locks somente quando estritamente necessário e segurá-los pelo menor tempo possível. Por exemplo, você nunca deve precisar usar um wake lock em uma atividade. Conforme descrito acima, se você quiser manter tela em sua atividade, use FLAG_KEEP_SCREEN_ON

Um caso legítimo para usar um wake lock pode ser um serviço em segundo plano que precisa de um wake lock para manter a CPU funcionando e fazer o trabalho enquanto a tela está Novamente, porém, essa prática deve ser minimizada por causa de seu impacto na duração da bateria.

Para usar um wake lock, a primeira etapa é adicionar o Permissão WAKE_LOCK para arquivo de manifesto do seu aplicativo:

<uses-permission android:name="android.permission.WAKE_LOCK" />

Se o app inclui um broadcast receiver que usa um serviço para fazer algum trabalho, Veja como definir um wake lock diretamente:

val wakeLock: PowerManager.WakeLock =
        (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
            newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyApp::MyWakelockTag").apply {
                acquire()
            }
        }

PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
        "MyApp::MyWakelockTag");
wakeLock.acquire();

Para liberar o wake lock, chame wakelock.release() Isso libera sua reivindicação para a CPU. É importante liberar um wake lock quando assim que o aplicativo terminar de usá-lo, para evitar o desgaste da bateria.