Un appareil Android laissé inactif s'endort rapidement pour éviter de décharger la batterie. Cependant, il peut arriver qu'une application doive activer l'écran ou le processeur et le maintenir activé pour effectuer une tâche.
L'approche que vous adoptez dépend des besoins de votre application. Toutefois, en règle générale, vous devez utiliser l'approche la plus légère possible pour votre application, afin de minimiser son impact sur les ressources système. Les sections suivantes décrivent comment gérer les cas où le comportement de sommeil par défaut de l'appareil n'est pas compatible avec les exigences de votre application.
Alternatives aux wakelocks
Avant d'ajouter la prise en charge du wakelock à votre application, déterminez si les cas d'utilisation de votre application sont compatibles avec l'une des solutions alternatives suivantes:
Si votre application effectue des téléchargements HTTP de longue durée, envisagez d'utiliser
DownloadManager.Si votre application synchronise des données à partir d'un serveur externe, envisagez de créer un adaptateur de synchronisation.
Si votre application repose sur des services en arrière-plan, envisagez d'utiliser JobScheduler ou Firebase Cloud Messaging pour déclencher ces services à des intervalles spécifiques.
Si vous devez continuer à exécuter votre application associée lorsqu'un appareil associé est à portée, utilisez le Gestionnaire d'appareils associés.
Gardez l'écran allumé
Certaines applications, comme les applications de jeu ou de cinéma, doivent garder l'écran allumé. Le meilleur moyen de procéder est d'utiliser FLAG_KEEP_SCREEN_ON dans votre activité (et uniquement dans une activité, jamais dans un service ou un autre composant d'application). Par exemple :
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);
}
}
L'avantage de cette approche est que, contrairement aux wakelocks (abordés dans la section Conserver le processeur activé), elle ne nécessite pas d'autorisation spéciale et la plate-forme gère correctement les déplacements de l'utilisateur entre les applications, sans que votre application ait à se soucier de la libération de ressources inutilisées.
Vous pouvez également implémenter cela dans le fichier XML de mise en page de votre application, à l'aide de l'attribut 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>
L'utilisation de android:keepScreenOn="true" équivaut à FLAG_KEEP_SCREEN_ON.
Vous pouvez utiliser la méthode qui convient le mieux à votre application. L'avantage de définir l'indicateur par programmation dans votre activité est qu'il vous permet de l'effacer par programmation plus tard, ce qui permet à l'écran de s'éteindre.
Mode Veille pour TV
Sur un téléviseur, FLAG_KEEP_SCREEN_ON doit être utilisé pour empêcher l'appareil de passer en mode Veille pendant la lecture d'une vidéo active. Lorsque FLAG_KEEP_SCREEN_ON n'est pas défini par l'activité de premier plan, l'appareil passe automatiquement en mode Veille après une période d'inactivité.
Laisser le processeur allumé
Si vous devez maintenir le processeur en cours d'exécution afin d'effectuer une tâche avant que l'appareil ne se mette en veille, vous pouvez utiliser une fonctionnalité de service système PowerManager appelée "wakelocks". Les wakelocks permettent à votre application de contrôler l'état d'alimentation de l'appareil hôte.
La création et la préservation de wakelocks peuvent avoir un impact considérable sur l'autonomie de la batterie de l'appareil hôte. Par conséquent, vous ne devez utiliser les wakelocks que lorsqu'ils sont strictement nécessaires et les maintenir le plus rapidement possible. Par exemple, vous ne devriez jamais avoir besoin d'utiliser un wakelock dans une activité. Comme décrit ci-dessus, si vous souhaitez garder l'écran allumé dans votre activité, utilisez FLAG_KEEP_SCREEN_ON.
Un cas légitime d'utilisation d'un wakelock peut être un service d'arrière-plan qui doit utiliser un wakelock pour que le processeur fonctionne lorsque l'écran est éteint. Là encore, cette pratique doit être réduite au maximum en raison de son impact sur l'autonomie de la batterie.
Pour utiliser un wakelock, la première étape consiste à ajouter l'autorisation WAKE_LOCK au fichier manifeste de votre application:
<uses-permission android:name="android.permission.WAKE_LOCK" />
Si votre application inclut un broadcast receiver qui utilise un service pour effectuer des tâches, voici comment définir un wakelock directement:
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();
Pour libérer le wakelock, appelez wakelock.release().
Cela lève la revendication du processeur. Il est important de publier un wakelock dès que votre application a fini de l'utiliser pour éviter de décharger la batterie.