Programmer des alarmes

Les alarmes présentent les caractéristiques suivantes:

• Ils vous permettent de déclencher des intents à des heures et/ou à des intervalles définis.

• Vous pouvez les utiliser avec des broadcast receivers pour planifier des tâches ou des WorkRequests pour effectuer d'autres opérations.

• Ils fonctionnent en dehors de votre application. Vous pouvez donc les utiliser pour déclencher des événements ou des actions même lorsque votre application n'est pas en cours d'exécution, et même si l'appareil lui-même est en veille.

• Ils vous aident à réduire les besoins en ressources de votre application. Vous pouvez planifier des opérations sans avoir à utiliser des minuteurs ni des services en cours d'exécution.

Définir une alarme inexacte

Lorsqu'une application définit une alarme inexacte, le système la diffuse à un moment donné. Les alarmes inexactes offrent certaines garanties concernant le moment de la diffusion de l'alarme, tout en respectant les restrictions d'économie de batterie telles que la mise en veille.

Les développeurs peuvent exploiter les garanties d'API suivantes pour personnaliser le moment de l'envoi des alarmes inexactes.

Envoyer une alarme après un délai spécifique

Si votre application appelle set(), setInexactRepeating() ou setAndAllowWhileIdle(), l'alarme ne se déclenche jamais avant l'heure de déclenchement fournie.

Sous Android 12 (niveau d'API 31) ou version ultérieure, le système appelle l'alarme dans l'heure suivant l'heure de déclenchement fournie, sauf si des restrictions d'économie de la batterie sont en vigueur, telles que l'économiseur de batterie ou la mise en veille.

Envoyer une alarme pendant une période donnée

Si votre application appelle setWindow(), l'alarme ne se déclenche jamais avant l'heure de déclenchement fournie. Sauf si des restrictions d'économie de la batterie sont en vigueur, l'alarme est envoyée dans la période spécifiée, à partir de l'heure de déclenchement donnée.

Si votre application cible Android 12 ou une version ultérieure, le système peut retarder l'appel d'une alarme inexacte avec une fenêtre temporelle d'au moins 10 minutes. Pour cette raison, les valeurs de paramètre windowLengthMillis inférieures à 600000 sont limitées à 600000.

Envoyer une alarme récurrente à des intervalles à peu près réguliers

Si votre application appelle setInexactRepeating(), le système appelle plusieurs alarmes:

1. La première alarme se déclenche dans la période spécifiée, à partir de l'heure de déclenchement donnée.
2. Les alarmes suivantes se déclenchent généralement une fois que la période spécifiée est écoulée. Le délai entre deux invocations consécutives de l'alarme peut varier.

Régler une alarme exacte

Le système appelle une alarme exacte à un moment précis dans le futur.

La plupart des applications peuvent planifier des tâches et des événements à l'aide d'alarmes inexactes pour effectuer plusieurs cas d'utilisation courants. Si la fonctionnalité de base de votre application dépend d'une alarme à l'heure exacte (par exemple, pour une application de réveil ou d'agenda), vous pouvez utiliser une alarme exacte.

Cas d'utilisation ne nécessitant pas forcément d'alarme exacte

La liste suivante répertorie les workflows courants ne nécessitant pas obligatoirement une alarme exacte :

Planifier des opérations de synchronisation pendant la durée de vie de votre application

La classe Handler inclut plusieurs bonnes méthodes pour gérer les opérations de chronométrage, telles que l'exécution d'une tâche toutes les n secondes, tant que votre application est active : postAtTime() et postDelayed(). Notez que ces API reposent sur l'temps de disponibilité du système et non sur le temps réel.

Travail d'arrière-plan planifié, comme la mise à jour de votre application et l'importation de journaux

WorkManager permet de planifier des tâches périodiques sensibles au facteur temps. Vous pouvez fournir un intervalle de répétition et flexInterval (15 minutes minimum) pour définir un environnement d'exécution précis pour le travail.

Action spécifiée par l'utilisateur devant se produire après une heure précise (même si le système est inactif)

Utilisez une alarme inexacte. Plus précisément, appelez setAndAllowWhileIdle().

Action spécifiée par l'utilisateur devant se produire après une heure précise

Utilisez une alarme inexacte. Plus précisément, appelez set().

Action spécifiée par l'utilisateur pouvant se produire dans un délai donné

Utilisez une alarme inexacte. Plus précisément, appelez setWindow(). Notez que si votre application cible Android 12 ou version ultérieure, la durée la plus courte autorisée est de 10 minutes.

Régler une alarme exacte

Votre application peut définir des alarmes exactes à l'aide de l'une des méthodes suivantes. Ces méthodes sont triées de sorte que celles situées en bas de la liste servent des tâches plus urgentes, mais exigent plus de ressources système.

setExact()

Appeler une alarme à une heure presque précise dans le futur, à condition que d'autres mesures d'économie de la batterie ne soient pas en vigueur.

Utilisez cette méthode pour définir des alarmes exactes, sauf si le travail de votre application est critique pour l'utilisateur.

setExactAndAllowWhileIdle()

Appeler une alarme à une heure presque précise à l'avenir, même si des mesures d'économie de la batterie sont en vigueur.

setAlarmClock()

Appeler une alarme à une heure précise à venir. Étant donné que ces alarmes sont très visibles par les utilisateurs, le système n'ajuste jamais leur heure de diffusion. Le système identifie ces alarmes comme les plus critiques et quitte les modes basse consommation si nécessaire pour les diffuser.

Consommation des ressources système

Lorsque le système déclenche les alarmes exactes que votre application définit, l'appareil consomme beaucoup de ressources, comme l'autonomie de la batterie, en particulier s'il est en mode Économiseur d'énergie. De plus, le système ne peut pas facilement regrouper ces requêtes afin d'utiliser les ressources plus efficacement.

Nous vous recommandons vivement de créer une alarme inexacte dans la mesure du possible. Pour effectuer une tâche plus longue, planifiez-la à l'aide de WorkManager ou de JobScheduler à partir de BroadcastReceiver de votre alarme. Pour effectuer une tâche lorsque l'appareil est en mode Doze, créez une alarme inexacte à l'aide de setAndAllowWhileIdle() et démarrez une tâche à partir de l'alarme.

Déclarer l'autorisation d'alarme exacte appropriée

Si votre application cible Android 12 ou une version ultérieure, vous devez obtenir l'accès spécial "Alarmes et rappels". Pour ce faire, déclarez l'autorisation SCHEDULE_EXACT_ALARM dans le fichier manifeste de votre application, comme indiqué dans l'extrait de code suivant:

<manifest ...>
    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM"/>
    <application ...>
        ...
    </application>
</manifest>

Si votre application cible Android 13 (niveau d'API 33) ou version ultérieure, vous pouvez déclarer l'autorisation SCHEDULE_EXACT_ALARM ou USE_EXACT_ALARM.

<manifest ...>
    <uses-permission android:name="android.permission.USE_EXACT_ALARM"/>
    <application ...>
        ...
    </application>
</manifest>

Bien que les autorisations SCHEDULE_EXACT_ALARM et USE_EXACT_ALARM signalent les mêmes fonctionnalités, elles sont accordées différemment et prennent en charge différents cas d'utilisation. Votre application doit utiliser des alarmes exactes et déclarer l'autorisation SCHEDULE_EXACT_ALARM ou USE_EXACT_ALARM uniquement si une fonction visible par l'utilisateur de votre application nécessite l'exécution d'actions à un moment précis.

USE_EXACT_ALARM

• Accordée automatiquement
• ne peuvent pas être révoquées par l'utilisateur ;
• Soumis à un futur règlement Google Play
• Cas d'utilisation limités

SCHEDULE_EXACT_ALARM

• Accordé par l'utilisateur
• Ensemble plus large de cas d'utilisation
• Les applications doivent vérifier que l'autorisation n'a pas été révoquée

L'autorisation SCHEDULE_EXACT_ALARM n'est pas accordée pour les nouvelles installations d'applications ciblant Android 13 (niveau d'API 33) ou version ultérieure. Si un utilisateur transfère des données d'application vers un appareil exécutant Android 14 via une opération de sauvegarde et de restauration, l'autorisation SCHEDULE_EXACT_ALARM sera refusée sur le nouvel appareil. Toutefois, si une application existante dispose déjà de cette autorisation, elle sera pré-accordée lorsque l'appareil passera à Android 14.

Remarque: Si l'alarme exacte est définie à l'aide d'un objet OnAlarmListener, comme avec l'API setExact, l'autorisation SCHEDULE_EXACT_ALARM n'est pas requise.

Utiliser l'autorisation SCHEDULE_EXACT_ALARM

Contrairement à USE_EXACT_ALARM, l'autorisation SCHEDULE_EXACT_ALARM doit être accordée par l'utilisateur. L'utilisateur et le système peuvent révoquer l'autorisation SCHEDULE_EXACT_ALARM.

Pour vérifier si l'autorisation est accordée à votre application, appelez canScheduleExactAlarms() avant d'essayer de définir une alarme exacte. Lorsque l'autorisation SCHEDULE_EXACT_ALARM est révoquée pour votre application, celle-ci s'arrête et toutes les futures alarmes exactes sont annulées. Cela signifie également que la valeur renvoyée par canScheduleExactAlarms() reste valide pendant tout le cycle de vie de votre application.

Lorsque l'autorisation SCHEDULE_EXACT_ALARMS est accordée à votre application, le système lui envoie la diffusion ACTION_SCHEDULE_EXACT_ALARM_PERMISSION_STATE_CHANGED. Votre application doit implémenter un broadcast receiver qui effectue les opérations suivantes:

1. Vérifie que votre application dispose toujours de l'accès spécial. Pour ce faire, appelez canScheduleExactAlarms(). Cette vérification protège votre application contre le cas où l'utilisateur accorde l'autorisation à votre application, puis la révoque presque immédiatement.
2. Reprogramme les alarmes exactes dont votre application a besoin en fonction de son état actuel. Cette logique doit être semblable à celle de votre application lorsqu'elle reçoit la diffusion ACTION_BOOT_COMPLETED.

Demander aux utilisateurs d'accorder l'autorisation SCHEDULE_EXACT_ALARM

Si nécessaire, vous pouvez rediriger les utilisateurs vers l'écran Alarmes et rappels dans les paramètres système, comme illustré dans la figure 1. Pour ce faire, procédez comme suit :

1. Dans l'interface utilisateur de votre application, expliquez à l'utilisateur pourquoi votre application doit planifier des alarmes exactes.
2. Appelez un intent qui inclut l'action d'intent ACTION_REQUEST_SCHEDULE_EXACT_ALARM.

Définir une alarme récurrente

Les alarmes récurrentes permettent au système d'envoyer des notifications à votre application de manière récurrente.

Une alarme mal conçue peut entraîner une décharge de la batterie et une charge importante sur les serveurs. Pour cette raison, sur Android 4.4 (niveau d'API 19) et versions ultérieures, toutes les alarmes répétitives sont des alarmes inexactes.

Une alarme récurrente présente les caractéristiques suivantes:

• Type d'alarme. Pour en savoir plus, consultez la section Choisir un type d'alarme.

• Heure de déclenchement. Si l'heure de déclenchement que vous spécifiez est passée, l'alarme se déclenche immédiatement.

• Intervalle de l'alarme. Par exemple, une fois par jour, toutes les heures ou toutes les cinq minutes.

• Intent en attente qui se déclenche lorsque l'alarme se déclenche. Lorsque vous définissez une deuxième alarme qui utilise le même intent en attente, elle remplace l'alarme d'origine.

Pour annuler un PendingIntent(), transmettez FLAG_NO_CREATE à PendingIntent.getService() pour obtenir une instance de l'intent (s'il existe), puis transmettez cet intent à AlarmManager.cancel().

val alarmManager =
    context.getSystemService(Context.ALARM_SERVICE) as? AlarmManager
val pendingIntent =
    PendingIntent.getService(context, requestId, intent,
                                PendingIntent.FLAG_NO_CREATE)
if (pendingIntent != null && alarmManager != null) {
  alarmManager.cancel(pendingIntent)
}

AlarmManager alarmManager =
    (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
PendingIntent pendingIntent =
    PendingIntent.getService(context, requestId, intent,
                                PendingIntent.FLAG_NO_CREATE);
if (pendingIntent != null && alarmManager != null) {
  alarmManager.cancel(pendingIntent);
}

Choisir un type d'alarme

L'un des premiers éléments à prendre en compte lors de l'utilisation d'une alarme récurrente est son type.

Il existe deux types d'horloges généraux pour les alarmes : le temps écoulé en temps réel et l'horloge en temps réel (RTC). Le temps réel écoulé utilise l'heure "depuis le démarrage du système" comme référence, et l'horloge en temps réel utilise l'heure UTC (horloge murale). Cela signifie que le temps réel écoulé est adapté pour définir une alarme en fonction du passage du temps (par exemple, une alarme qui se déclenche toutes les 30 secondes), car il n'est pas affecté par le fuseau horaire ni les paramètres régionaux. Le type d'horloge en temps réel est plus adapté aux alarmes qui dépendent des paramètres régionaux actuels.

Les deux types disposent d'une version "réveil", qui indique de réveiller le processeur de l'appareil si l'écran est éteint. Cela garantit que l'alarme se déclenchera à l'heure prévue. Cela est utile si votre application présente une dépendance temporelle. Par exemple, si elle dispose d'une période limitée pour effectuer une opération particulière. Si vous n'utilisez pas la version de réveil de votre type d'alarme, toutes les alarmes récurrentes se déclencheront la prochaine fois que votre appareil sera activé.

Si vous souhaitez simplement que votre alarme se déclenche à un intervalle particulier (par exemple, toutes les demi-heures), utilisez l'un des types de temps réel écoulé. En général, il s'agit de la meilleure option.

Si vous devez déclencher une alarme à une heure précise de la journée, choisissez l'un des types d'horloge en temps réel basés sur une horloge. Notez toutefois que cette approche peut présenter certains inconvénients. L'application peut ne pas être bien traduite dans d'autres langues, et si l'utilisateur modifie le paramètre d'heure de l'appareil, cela peut entraîner un comportement inattendu dans votre application. L'utilisation d'un type d'alarme d'horloge en temps réel ne permet pas non plus de bien faire évoluer l'application, comme indiqué ci-dessus. Nous vous recommandons d'utiliser une alarme "temps écoulé en temps réel" si possible.

Voici la liste des types:

• ELAPSED_REALTIME : déclenche l'intent en attente en fonction du temps écoulé depuis le démarrage de l'appareil, mais ne le réveille pas. Le temps écoulé inclut le temps pendant lequel l'appareil était en veille.

• ELAPSED_REALTIME_WAKEUP : réveille l'appareil et déclenche l'intent en attente une fois le délai spécifié écoulé depuis le démarrage de l'appareil.

• RTC : déclenche l'intent en attente à l'heure spécifiée, mais ne réveille pas l'appareil.

• RTC_WAKEUP: active l'appareil pour déclencher l'intent en attente à l'heure spécifiée.

Exemples d'alarmes en temps réel écoulées

Voici quelques exemples d'utilisation de ELAPSED_REALTIME_WAKEUP.

Réveiller l'appareil pour déclencher l'alarme dans 30 minutes, puis toutes les 30 minutes par la suite:

// Hopefully your alarm will have a lower frequency than this!
alarmMgr?.setInexactRepeating(
        AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() + AlarmManager.INTERVAL_HALF_HOUR,
        AlarmManager.INTERVAL_HALF_HOUR,
        alarmIntent
)

// Hopefully your alarm will have a lower frequency than this!
alarmMgr.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() + AlarmManager.INTERVAL_HALF_HOUR,
        AlarmManager.INTERVAL_HALF_HOUR, alarmIntent);

Pour réveiller l'appareil et déclencher une alarme unique (non répétitive) dans une minute:

private var alarmMgr: AlarmManager? = null
private lateinit var alarmIntent: PendingIntent
...
alarmMgr = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
alarmIntent = Intent(context, AlarmReceiver::class.java).let { intent ->
    PendingIntent.getBroadcast(context, 0, intent, 0)
}

alarmMgr?.set(
        AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() + 60 * 1000,
        alarmIntent
)

private AlarmManager alarmMgr;
private PendingIntent alarmIntent;
...
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, AlarmReceiver.class);
alarmIntent = PendingIntent.getBroadcast(context, 0, intent, 0);

alarmMgr.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() +
        60 * 1000, alarmIntent);

Exemples d'alarmes de réveil en temps réel

Voici quelques exemples d'utilisation de RTC_WAKEUP.

Activez l'appareil pour déclencher l'alarme vers 14h00, puis répétez l'opération une fois par jour à la même heure :

// Set the alarm to start at approximately 2:00 p.m.
val calendar: Calendar = Calendar.getInstance().apply {
    timeInMillis = System.currentTimeMillis()
    set(Calendar.HOUR_OF_DAY, 14)
}

// With setInexactRepeating(), you have to use one of the AlarmManager interval
// constants--in this case, AlarmManager.INTERVAL_DAY.
alarmMgr?.setInexactRepeating(
        AlarmManager.RTC_WAKEUP,
        calendar.timeInMillis,
        AlarmManager.INTERVAL_DAY,
        alarmIntent
)

// Set the alarm to start at approximately 2:00 p.m.
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 14);

// With setInexactRepeating(), you have to use one of the AlarmManager interval
// constants--in this case, AlarmManager.INTERVAL_DAY.
alarmMgr.setInexactRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
        AlarmManager.INTERVAL_DAY, alarmIntent);

Réveillez l'appareil pour qu'il déclenche l'alarme à 8h30 précisément, puis toutes les 20 minutes par la suite :

private var alarmMgr: AlarmManager? = null
private lateinit var alarmIntent: PendingIntent
...
alarmMgr = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
alarmIntent = Intent(context, AlarmReceiver::class.java).let { intent ->
    PendingIntent.getBroadcast(context, 0, intent, 0)
}

// Set the alarm to start at 8:30 a.m.
val calendar: Calendar = Calendar.getInstance().apply {
    timeInMillis = System.currentTimeMillis()
    set(Calendar.HOUR_OF_DAY, 8)
    set(Calendar.MINUTE, 30)
}

// setRepeating() lets you specify a precise custom interval--in this case,
// 20 minutes.
alarmMgr?.setRepeating(
        AlarmManager.RTC_WAKEUP,
        calendar.timeInMillis,
        1000 * 60 * 20,
        alarmIntent
)

private AlarmManager alarmMgr;
private PendingIntent alarmIntent;
...
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, AlarmReceiver.class);
alarmIntent = PendingIntent.getBroadcast(context, 0, intent, 0);

// Set the alarm to start at 8:30 a.m.
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 8);
calendar.set(Calendar.MINUTE, 30);

// setRepeating() lets you specify a precise custom interval--in this case,
// 20 minutes.
alarmMgr.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
        1000 * 60 * 20, alarmIntent);

Déterminez la précision requise pour votre alarme

Comme décrit précédemment, le choix du type d'alarme est souvent la première étape de la création d'une alarme. Une autre distinction concerne le niveau de précision dont vous avez besoin pour votre alarme. Pour la plupart des applications, setInexactRepeating() est le bon choix. Lorsque vous utilisez cette méthode, Android synchronise plusieurs alarmes répétitives inexactes et les déclenche en même temps. Cela réduit l'utilisation de la batterie.

Si possible, évitez d'utiliser des alarmes exactes. Toutefois, pour les applications rares qui ont des exigences temporelles strictes, vous pouvez définir une alarme exacte en appelant setRepeating().

Avec setInexactRepeating(), vous ne pouvez pas spécifier d'intervalle personnalisé comme vous le pouvez avec setRepeating(). Vous devez utiliser l'une des constantes d'intervalle, telles que INTERVAL_FIFTEEN_MINUTES, INTERVAL_DAY, etc. Pour obtenir la liste complète, consultez AlarmManager.

Annuler une alarme

En fonction de votre application, vous pouvez inclure la possibilité d'annuler l'alarme. Pour annuler une alarme, appelez cancel() sur le Gestionnaire d'alarmes, en transmettant l'PendingIntent que vous ne souhaitez plus déclencher. Exemple :

// If the alarm has been set, cancel it.
alarmMgr?.cancel(alarmIntent)

// If the alarm has been set, cancel it.
if (alarmMgr!= null) {
    alarmMgr.cancel(alarmIntent);
}

Démarrer une alarme lorsque l'appareil redémarre

Par défaut, toutes les alarmes sont annulées lorsqu'un appareil s'arrête. Pour éviter cela, vous pouvez concevoir votre application de sorte qu'elle redémarre automatiquement une alarme récurrente si l'utilisateur redémarre l'appareil. Cela garantit que AlarmManager continuera à effectuer sa tâche sans que l'utilisateur ait besoin de redémarrer manuellement l'alarme.

Voici la procédure à suivre :

1. Définissez l'autorisation RECEIVE_BOOT_COMPLETED dans le fichier manifeste de votre application. Cela permet à votre application de recevoir le ACTION_BOOT_COMPLETED diffusé une fois le démarrage du système terminé (cela ne fonctionne que si l'application a déjà été lancée par l'utilisateur au moins une fois):

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

2. Implémentez un BroadcastReceiver pour recevoir la diffusion:

   Kotlin

   class SampleBootReceiver : BroadcastReceiver() {
   
       override fun onReceive(context: Context, intent: Intent) {
           if (intent.action == "android.intent.action.BOOT_COMPLETED") {
               // Set the alarm here.
           }
       }
   }

   Java

   public class SampleBootReceiver extends BroadcastReceiver {
   
       @Override
       public void onReceive(Context context, Intent intent) {
           if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED")) {
               // Set the alarm here.
           }
       }
   }

3. Ajoutez le récepteur au fichier manifeste de votre application avec un filtre d'intent qui filtre sur l'action ACTION_BOOT_COMPLETED:

   <receiver android:name=".SampleBootReceiver"
           android:enabled="false">
       <intent-filter>
           <action android:name="android.intent.action.BOOT_COMPLETED"></action>
       </intent-filter>
   </receiver>

   Notez que dans le fichier manifeste, le récepteur de démarrage est défini sur android:enabled="false". Cela signifie que le récepteur ne sera pas appelé, sauf si l'application l'active explicitement. Cela empêche l'appel inutile du récepteur de démarrage. Vous pouvez activer un récepteur (par exemple, si l'utilisateur définit une alarme) comme suit:

   Kotlin

   val receiver = ComponentName(context, SampleBootReceiver::class.java)
   
   context.packageManager.setComponentEnabledSetting(
           receiver,
           PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
           PackageManager.DONT_KILL_APP
   )

   Java

   ComponentName receiver = new ComponentName(context, SampleBootReceiver.class);
   PackageManager pm = context.getPackageManager();
   
   pm.setComponentEnabledSetting(receiver,
           PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
           PackageManager.DONT_KILL_APP);

   Une fois le récepteur activé de cette manière, il restera activé, même si l'utilisateur redémarre l'appareil. En d'autres termes, l'activation du récepteur par programmation remplace le paramètre du fichier manifeste, même après un redémarrage. Le récepteur reste activé jusqu'à ce que votre application le désactive. Vous pouvez désactiver un récepteur (par exemple, si l'utilisateur annule une alarme) comme suit:

   Kotlin

   val receiver = ComponentName(context, SampleBootReceiver::class.java)
   
   context.packageManager.setComponentEnabledSetting(
           receiver,
           PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
           PackageManager.DONT_KILL_APP
   )

   Java

   ComponentName receiver = new ComponentName(context, SampleBootReceiver.class);
   PackageManager pm = context.getPackageManager();
   
   pm.setComponentEnabledSetting(receiver,
           PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
           PackageManager.DONT_KILL_APP);

Appeler des alarmes lorsque l'appareil est en mode Doze

Les appareils équipés d'Android 6.0 (niveau d'API 23) sont compatibles avec le mode Doze, qui permet d'augmenter l'autonomie de la batterie de l'appareil. Les alarmes ne se déclenchent pas lorsque l'appareil est en mode Sommeil. Toutes les alarmes programmées sont différées jusqu'à ce que l'appareil quitte le mode Sommeil. Si vous devez effectuer des tâches même lorsque l'appareil est inactif, plusieurs options s'offrent à vous:

• Réglez une alarme exacte.

• Utilisez l'API WorkManager, conçue pour effectuer des tâches en arrière-plan. Vous pouvez indiquer au système qu'il doit accélérer votre travail afin qu'il se termine le plus rapidement possible. Pour en savoir plus, consultez la section Planifier des tâches avec WorkManager.

Bonnes pratiques

Chaque choix que vous faites lors de la conception de votre alarme récurrente peut avoir des conséquences sur la façon dont votre application utilise (ou abuse) les ressources système. Imaginons, par exemple, une application populaire qui se synchronise avec un serveur. Si l'opération de synchronisation est basée sur l'heure de l'horloge et que chaque instance de l'application se synchronise à 23h00, la charge sur le serveur peut entraîner une latence élevée, voire un "refus de service". Suivez ces bonnes pratiques pour utiliser les alarmes:

• Ajoutez de l'aléatoire (jitter) à toutes les requêtes réseau déclenchées par une alarme répétée:

  • Effectuez une tâche locale lorsque l'alarme se déclenche. "Travail local" désigne tout ce qui n'est pas exécuté sur un serveur ni ne nécessite les données du serveur.

  • En même temps, planifiez l'alarme contenant les requêtes réseau pour qu'elle se déclenche à un moment aléatoire.

• Limitez la fréquence des alarmes.

• Ne réveillez pas l'appareil inutilement (ce comportement est déterminé par le type d'alarme, comme décrit dans la section Choisir un type d'alarme).

• Ne définissez pas l'heure de déclenchement de l'alarme plus précisément que nécessaire.

  Utilisez setInexactRepeating() à la place de setRepeating(). Lorsque vous utilisez setInexactRepeating(), Android synchronise les alarmes récurrentes de plusieurs applications et les déclenche en même temps. Cela réduit le nombre total de fois où le système doit réveiller l'appareil, ce qui réduit l'usure de la batterie. Depuis Android 4.4 (niveau d'API 19), toutes les alarmes répétitives sont des alarmes inexactes. Notez que même si setInexactRepeating() est une amélioration par rapport à setRepeating(), il peut toujours submerger un serveur si chaque instance d'une application accède au serveur à peu près au même moment. Par conséquent, pour les requêtes réseau, ajoutez un peu de hasard à vos alarmes, comme indiqué précédemment.

• Dans la mesure du possible, évitez de baser votre alarme sur l'heure de l'horloge.

  Les alarmes récurrentes basées sur un déclencheur précis ne sont pas adaptées à la mise à l'échelle. Utilisez ELAPSED_REALTIME si possible. Les différents types d'alarmes sont décrits plus en détail dans la section suivante.