LazylifecycleCallbacks

Rappels lazylifecycle

Les rappels Lazylifecycle sont un cadre simple pour reporter vos tâches non essentielles, et les initialisations hors du chemin de lancement de l'écran tout en conservant les mêmes garanties d'exécution des rappels de cycle de vie Android.

Fondamentaux des rappels paresseux

• Premier tirage: Lorsque l'application est lancée, Play Store suit les numéros de lancement froids, chauds et chauds. Et il le fait en mesurant la vitesse à laquelle votre application est en mesure de dessiner votre première trame. L'application peut démarrer via Launcher, Notifications, DeepLinks, etc., et chacun pourrait atterrir l'utilisateur dans différents écrans. L'application est considérée comme ayant rendu son premier écran lorsque le marqueur "affiché" est affiché sur le logcat. Cela a toujours montré après tous les rappels vers le haut tels que OnCreate, Onstart et OnResume sont revenus.

• Ainsi, tout code qui s'exécute dans OnCreate, OnStart et ONRESUME, et d'autres rappels ascendants (sans mentionner des choses comme Onpostreume) a le potentiel de rendre le temps de lancement de l'écran mauvais. Ainsi, il est conseillé de supprimer le code différemment loin des rappels du cycle de vie Android.

• Mais où devons-nous le déplacer? Nous pouvons faire les choses à la demande, mais tout ne peut pas être déplacé sur le plan. Par exemple, vous souhaitez commencer à passer les appels N / W pour récupérer les images dès que possible. Ici, nous ne voulons pas qu'il commence pendant que le rendu de l'écran se produit, mais l'écran du moment se rend avec la vue d'espace réservé, nous devons commencer les appels N / W-DB. Supposons que vous souhaitiez charger le brouillon d'un e-mail de la base de données, nous aimerions d'abord rendre l'écran de composition, puis commencer à récupérer le projet.

Apis

• activer () - active des rappels paresseux sur une activité, généralement réalisée dans onResume ()
• Deagtivate () - désactive les rappels paresseux sur une activité, généralement réalisé dans onPause ()
• WatchEdView - Chaque écran a une vue unique qui est critique pour cet écran, et le rendu sur cet écran peut être considéré comme un lancement. Si aucune vue observée n'est fournie ou identifiée, la vue de décoration ne peut être utilisée.
• Supportslazylifecyclecallbacks - Cela nous aide à bord dans le cadre progressivement et nous permet de mener des expériments pour mesurer l'amélioration. Si cela renvoie faux pour une activité, les rappels de cycle de vie paresseux ne sont pas activés pour cet écran. Chaque écran peut remplacer sa valeur séparément.
• LazylifecycleCallbacks - Toute activité / fragment qui veut à bord de ces rappels doit implémenter cette interface.

Les rappels paresseux fournis par le cadre

• OnlazyCreate - exécute une fois par activité / fragment tout comme OnCreate, mais après le premier tirage à l'écran ou à l'expiration du délai d'attente.
• OnlazyStart - Excite si l'activité reprend à partir d'un état arrêté, mais après le 1er tirage à l'écran, les finitions de l'écran ou sur l'expiration du délai d'attente.
• OnlazyResume - excite si l'activité reprend à partir d'un état interrompu, mais après le premier tirage à l'écran, les finitions de l'écran ou sur l'expiration du délai d'attente.
• OnViewCreatEdlazy (vue) - Ceci est appelé uniquement pour les fragments après les finitions de 1er tirage à l'écran.

Commande relative de rappels paresseux

L'ordre de ces rappels est maintenu selon Android. Dans une activité, OnlazyCreate () sera suivi de sur LazyStart (), suivi de OnlazyResume (). En fragments, OnlazyCreate () sera suivi par OnViewCreatedlazy (vue), suivi de OnlazyStart () suivi de OnlazyResume (). Une chose à l'esprit est que tous les rappels paresseux se produisent après que les déclencheurs du gestionnaire de cycle de vie paresseux sont satisfaits. Ils ne s'entrelacent pas avec les rappels de cycle de vie Android.

Comment configurer

Ajoutez le code ci-dessous à la build.gradle File dependencies { implementation 'com.github.microsoft:LazylifecycleCallbacks:v1.0' }

1. Implémentez l'interface LazyLifecycleCallbacks dans l'activité (préférable une BaseActivity ) et fournissent les implémentations par défaut de la méthode.
2. Créez une instance de lazylifecycleManager dans onCreate() .
3. Appelez lifecycleManager.activate() dans onResume ,
4. et appeler lifecycleManager.deactivate() dans onPause()
5. Remplacer supportsLazyLifecycleCallbacks() à true .
6. Vous avez terminé. D'autres implémentations de votre BaseActivity peuvent désormais remplacer les rappels de cycle de vie paresseux et l'utiliser.

Voir le code ci-dessous:

 abstract class BaseActivity : AppCompatActivity (), LazyLifecycleCallbacks {

    protected lateinit var lazyLifecycleManager : LazyLifecycleManager

    override fun onCreate ( savedInstanceState : Bundle ? ) {
        super .onCreate(savedInstanceState)
        lazyLifecycleManager = ViewBasedLazyLifecycleManager ( this )
    }

    override fun onResume () {
        super .onResume()
        lazyLifecycleManager.activate()
    }

    override fun onPause () {
        super .onPause()
        lazyLifecycleManager.deactivate()
    }

    override fun onLazyCreate () {}

    override fun onLazyStart () {}

    override fun onLazyResume () {}

    override fun supportsLazyLifecycleCallbacks (): Boolean = false
}