Maintenir l'appareil activé

Pour éviter de décharger la batterie, un appareil Android inactif tombe rapidement endormi(e). Cependant, il peut arriver qu'une application doive réactiver l'écran. ou le CPU et le garder activé pour terminer un travail.

L'approche à adopter dépend des besoins de votre application. Toutefois, en règle générale, est d'adopter l'approche la plus légère possible pour minimiser l'impact de votre application sur les ressources système. Les sections suivantes décrire comment gérer les cas où le comportement de sommeil par défaut de l'appareil est incompatible avec les exigences de votre application.

Alternatives à l'utilisation des wakelocks

Avant d'ajouter la prise en charge des wakelocks à votre application, déterminez si son utilisation 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 d'arrière-plan, envisagez d'utiliser JobScheduler ou Firebase Cloud Messaging pour déclencher ces services à des intervalles spécifiques.

• Si vous devez maintenir l'application associée en cours d'exécution chaque fois qu'un appareil associé à portée, utilisez le Gestionnaire d'appareils Companion.

Gardez l'écran allumé

Certaines applications, telles que des jeux ou des applications de films, doivent laisser l'écran allumé. La Le meilleur moyen d'y parvenir est d'utiliser FLAG_KEEP_SCREEN_ON dans votre activité (et uniquement dans une activité, jamais dans un service ou une autre application) ; ). 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 (décrits dans la section Conserver les (CPU activé)), aucune autorisation spéciale n'est requise. De plus, la plate-forme gère correctement l'utilisateur qui passe d'une application à l'autre, sans que celle-ci n'ait besoin de s'inquiéter de libérer les ressources inutilisées.

Vous pouvez aussi implémenter cela dans le fichier XML de mise en page de votre application, en utilisant 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 à utiliser FLAG_KEEP_SCREEN_ON Vous pouvez utiliser la méthode la plus adaptée à votre application. L’avantage de définir l'indicateur programmatique dans votre activité est qu'il vous permet en effaçant l'indicateur par programmation et en autorisant ainsi l'écran à tourner désactivée.

Remarque :Il n'est pas nécessaire de supprimer le contenu FLAG_KEEP_SCREEN_ON sauf si vous ne voulez plus que l'écran reste allumé dans votre application en cours d'exécution (par exemple, si vous souhaitez que l'écran s'éteigne après un certain délai inactivité). Le gestionnaire de fenêtres veille à ce que les éléments se produire lorsque l'application passe en arrière-plan ou revient au premier plan. Toutefois, si vous souhaitez supprimer explicitement l'indicateur et autoriser ainsi l'écran à passer utilisez clearFlags(): getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON).

Mode Veille pour la télévision

À la télévision, FLAG_KEEP_SCREEN_ON doit être utilisé pour éviter que l'appareil entre Mode Veille pendant la lecture vidéo en cours. Lorsque FLAG_KEEP_SCREEN_ON n'est pas défini par l'activité au 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 un travail avant que le l'appareil se met en veille, vous pouvez Fonctionnalité de service système PowerManager appelés wakelocks. Les wakelocks permettent à votre application de contrôler l'état de l'alimentation de l'appareil hôte.

La création et le maintien de wakelocks peuvent avoir un impact considérable sur l'état de la batterie. Vous ne devez donc utiliser les wakelocks qu'en cas d'absolue nécessité. et maintenez-les le plus rapidement possible. Par exemple, vous ne devriez jamais avoir utiliser un wakelock dans une activité. Comme décrit ci-dessus, si vous souhaitez conserver écran activé dans votre activité, utilisez FLAG_KEEP_SCREEN_ON

Un cas légitime d'utilisation d'un wakelock pourrait être un service d'arrière-plan qui doit utiliser un wakelock pour que le CPU reste en cours d’exécution pour faire son travail lorsque l’écran est désactivée. Là encore, cette pratique doit être minimisée en raison de son impact de la batterie.

Pour utiliser un wakelock, vous devez d'abord ajouter le Autorisation WAKE_LOCK à le 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 un travail, 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 déverrouiller le wakelock, appelez wakelock.release() Votre revendication auprès du processeur est alors levée. Il est important de débloquer un wakelock dès que votre application a fini de l'utiliser pour éviter de vider la batterie.