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:
Kotlin
class MainActivity : Activity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) } }
Java
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:
Kotlin
val wakeLock: PowerManager.WakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).run { newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyApp::MyWakelockTag").apply { acquire() } }
Java
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.