Programmer des alarmes

Les alarmes (basées sur la classe AlarmManager) vous permettent d'effectuer des opérations basées sur le temps en dehors de la durée de vie de votre application. Par exemple, vous pouvez utiliser une alarme pour lancer une opération de longue durée, comme démarrer un service une fois par jour pour télécharger des prévisions météo.

Les alarmes ont 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 jobs ou 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 programmer des opérations sans utiliser de minuteurs ni de services en cours d'exécution.

Remarque : Pour les opérations de synchronisation qui sont garanties de se produire pendant la durée de vie de votre application, envisagez d'utiliser la classe Handler avec Timer et Thread. Cette approche permet à Android de mieux contrôler les ressources système.

Définir une alarme inexacte

Lorsqu'une application définit une alarme inexacte, le système déclenche l'alarme à 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.

Remarque :La plupart des applications peuvent planifier des tâches et des événements à l'aide d'alarmes inexactes. Si votre la fonctionnalité de base de l'application dépend d'une alarme programmée avec précision, par exemple pour une alarme une application d'horloge ou d'agenda, vous pouvez utiliser une alarme exacte à la place.

Les développeurs peuvent utiliser les garanties d'API suivantes pour personnaliser le délai le déclenchement de l'alarme inexact.

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 indiquée.

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 batterie sont en vigueur, l'alarme est déclenchée livrés dans la période spécifiée, à partir du déclencheur donné en temps réel.

Si votre application cible Android 12 ou une version ultérieure, le système peut retarder l'appel d'une alarme inexacte associée à une période 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 fenêtre horaire spécifiée, au moment précis du déclenchement.
2. Les alarmes suivantes se déclenchent généralement après le délai spécifié s'écoule. Le temps écoulé entre deux appels consécutifs 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.

Remarque : Si votre application cible Android 12 ou version ultérieure, vous devez déclarer l'une des autorisations "Alarmes et rappels". Sinon, une exception SecurityException se produit.

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 le temps d'activité du système. et non en 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 définir 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 de la période la plus courte autorisée est de 10 minutes.

Comment 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 classées de sorte que celles qui sont proches du bas de la liste servent le plus les tâches urgentes, mais qui nécessitent plus de ressources système.

setExact()

Appeler une alarme à une heure presque précise à l'avenir, à 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.

Attention : Lorsque votre application planifie une alarme exacte à l'aide de cette méthode, l'appel de l'alarme peut affecter considérablement les ressources de l'appareil, comme l'autonomie de la batterie.

Consommation des ressources du système

Lorsque le système déclenche les alarmes exactes définies par votre application, l'appareil consomme beaucoup de ressources, comme l'autonomie de la batterie, surtout un mode Économie d'énergie. De plus, le système ne peut pas traiter facilement ces requêtes par lot afin d'utiliser les ressources plus efficacement.

Nous vous recommandons vivement de créer une alarme inexacte chaque fois que 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 des tâches pendant l'appareil est en mode Sommeil, créez une alarme inexacte en utilisant setAndAllowWhileIdle(), et démarrer une tâche à partir de l'alarme.

Remarque :Android considère les alarmes exactes comme critiques et sensibles à l'heure. sans interruption. C'est pourquoi les alarmes exactes ne sont pas affectées par lancement de service de premier plan restrictions.

Déclarer l'autorisation d'utiliser des alarmes exactes appropriées

Si votre application cible Android 12 ou une version ultérieure, vous devez obtenir "Alarmes et rappels" un accès spécial des applications. 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 une version ultérieure, vous pouvez déclarez soit SCHEDULE_EXACT_ALARM, ou USE_EXACT_ALARM l'autorisation.

<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 capacités, mais sont accordées différemment et acceptent différentes dans différents cas d'utilisation. Votre application doit utiliser des alarmes exactes et déclarer Autorisation SCHEDULE_EXACT_ALARM ou USE_EXACT_ALARM, uniquement si un utilisateur dans votre application nécessite des actions à un moment précis.

USE_EXACT_ALARM

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

SCHEDULE_EXACT_ALARM

• Accordée 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 pré-accordée aux nouvelles installations de 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 le les mises à niveau d'appareils vers 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é 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 appli, appelez canScheduleExactAlarms() avant d'essayer de régler une alarme exacte. Lorsque l'autorisation SCHEDULE_EXACT_ALARM est révoqué pour votre appli, celle-ci s'arrête et toutes les alarmes exactes futures sont annulées. Cela signifie également que la valeur renvoyée par canScheduleExactAlarms() reste valide pendant l'intégralité du 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 une diffusion récepteur qui effectue 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 dans le cas où l'utilisateur lui accorde l'autorisation l'autorisation, puis la révoque presque immédiatement après.
2. Reprogramme les alarmes exactes dont votre application a besoin en fonction de son état actuel. Cette logique est semblable à celle de votre application lorsqu'elle reçoit le ACTION_BOOT_COMPLETED annonce.

Demander aux utilisateurs d'accorder l'autorisation SCHEDULE_EXACT_ALARM

Figure 1. Page "Alarmes et rappels" des accès spéciaux des applications dans les paramètres système, où les utilisateurs peuvent autoriser votre application à définir des alarmes exactes.

Si nécessaire, vous pouvez rediriger les utilisateurs vers le menu Alarmes et l'écran des rappels du 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épétées permettent au système d'avertir votre application lors d'une programmation.

Une alarme mal conçue peut décharger la batterie et exercer une charge importante sur serveurs. Pour cette raison, sur Android 4.4 (niveau d'API 19) ou version ultérieure, Les alarmes répétées sont des alarmes inexactes.

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

• Type d'alarme. Pour plus d'informations, 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.

• Un intent en attente qui se déclenche lorsque l'alarme est déclenchée. Lorsque vous définissez un 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 (le cas échéant), puis le transmettre à AlarmManager.cancel()

Kotlin

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)
}

Java

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);
}

Remarque :Si la PendingIntent a été créée avec FLAG_ONE_SHOT elle ne peut pas être annulée.

Choisir un type d'alarme

L'une des premières considérations concernant l'utilisation d'une alarme récurrente est le type doit être.

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é permet de définir une alarme en fonction du temps écoulé (par comme une alarme qui se déclenche toutes les 30 secondes), car elle n'est pas affectée par fuseau horaire ou paramètres régionaux. Le type d'horloge en temps réel convient mieux aux alarmes 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 a une dépendance temporelle. Par exemple, s'il comporte une fenêtre limitée pour effectuer une opération particulière. Si vous n'utilisez pas version wakeup de votre type d'alarme, toutes les alarmes récurrentes se déclencheront lorsque votre appareil sera de nouveau 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, est le meilleur choix.

Si vous souhaitez que votre alarme se déclenche à une heure précise de la journée, choisissez-en une des types d'horloges en temps réel basées sur l'horloge. Notez toutefois que cette approche peut présenter certains inconvénients. Il est possible que l'application ne fonctionne pas correctement dans les autres langues. si l'utilisateur modifie le paramètre d'heure de l'appareil, cela peut provoquer un comportement inattendu dans votre application. L'utilisation d'un type d'alarme d'horloge en temps réel n'est pas non plus adaptée, car comme expliqué 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 de la durée écoulée depuis que l'appareil démarré, mais ne réactive pas l’appareil. La Le temps écoulé inclut le temps de veille de l'appareil.

• 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 au moment spécifié, mais ne réactive 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 :

Kotlin

// 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
)

Java

// 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);

Activez l'appareil pour déclencher une alarme unique (non récurrente) en une minute:

Kotlin

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
)

Java

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 en temps réel

Voici quelques exemples d'utilisation de RTC_WAKEUP.

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

Kotlin

// 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
)

Java

// 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);

Activez l'appareil pour déclencher l'alarme à 8h30 précisément et toutes les 20 minutes par la suite:

Kotlin

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
)

Java

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 et incendies qui se répètent de façon inexacte. en même temps. Cela réduit la décharge de la batterie.

Si possible, évitez d'utiliser des alarmes exactes. Toutefois, pour l'application rare en fonction du temps nécessaire, 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, comme INTERVAL_FIFTEEN_MINUTES, INTERVAL_DAY, et ainsi de suite. 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 :

Kotlin

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

Java

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

Lancer une alarme lorsque l'appareil redémarre

Par défaut, toutes les alarmes sont annulées lorsqu'un appareil s'éteint. Pour éviter cela, vous pouvez concevoir votre application pour redémarrer 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 la 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é, il reste 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 jusqu'à ce que votre application la 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

Compatibilité avec les appareils équipés d'Android 6.0 (niveau d'API 23) Sommeil , ce qui contribue à prolonger 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 avez besoin de même lorsque l'appareil est inactif, plusieurs options s'offrent à vous disponibles:

• Régler une alarme exacte

• Utilisez l'API WorkManager, conçue pour effectuer le travail 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 Planifier des tâches avec WorkManager

Bonnes pratiques

Chaque choix que vous faites dans la conception de votre alarme récurrente peut avoir des conséquences de la manière dont votre application utilise (ou abuse) des 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'horloge et que chaque instance de l'application est synchronisée à 23 h 00, la charge sur le peut entraîner une latence élevée, voire "déni de service". Suivez ces bonnes pratiques pour utiliser les alarmes :

• ajouter un caractère aléatoire (gigue) à toutes les requêtes réseau qui se déclenche à la suite d’une alarme récurrente:

  • 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éactivez pas l'appareil inutilement (ce comportement est déterminé par le type d'alarme, comme décrit dans Choisir un type d'alarme).

• Ne définissez pas l'heure de déclenchement de votre alarme plus précise qu'elle ne devrait l'être.

  Utilisez setInexactRepeating() à la place de setRepeating(). Lorsque vous utilisez setInexactRepeating(), Android synchronise les alarmes répétées de plusieurs applications et les incendies 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. Remarque bien que setInexactRepeating() est une amélioration par rapport setRepeating(), Elle peut toujours surcharger un serveur si toutes les instances d'une application atteignent le 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épétées, basées sur une heure de déclenchement précise, ne sont pas adaptées. Utilisez ELAPSED_REALTIME si possible. Les différentes alarmes sont décrits plus en détail dans la section suivante.