Utilisation d’Android Jetpack Lifecycle-Aware Components – Développement de logiciels
En fait, l’un des principaux problèmes du développement Android est lié aux problèmes de gestion du cycle de vie. En d’autres termes, le fait de ne pas gérer correctement les cycles de vie des applications peut entraîner des problèmes problématiques tels que des fuites de mémoire et des plantages. Les composants compatibles avec le cycle de vie faisant partie des composants de l’architecture Android accomplissent des tâches en réponse à un changement de l’état du cycle de vie d’un autre composant, comme les activités et les fragments. Par conséquent, ces composants vous aident à créer un code mieux organisé et souvent plus léger, plus facile à maintenir et à tester. Cet essai vise à considérer les composants Android Jetpack Lifecycle comme une approche avancée pour la gestion des cycles de vie dans le développement Android.
Présentation et introduction
Composants d’architecture Android est une nouvelle collection de bibliothèques de Google, qui vise à nous aider à concevoir des applications Android robustes, testables et maintenables. En d’autres termes, cette bibliothèque nous aide à gérer les données à travers les événements du cycle de vie et les changements de configuration, et également à créer une architecture appropriée pour nos classes pour la maintenance et les tests.
Fondamentalement, la plupart des composants Android ont un cycle de vie qui leur est associé. Auparavant, vous étiez responsable de la gestion du cycle de vie de votre application, ce qui n’était pas toujours une tâche facile, en particulier pour plusieurs appels asynchrones de manière simultanée. Ne pas gérer correctement les cycles de vie des applications peut entraîner des problèmes problématiques tels que des fuites de mémoire et des plantages. Bien que vous ayez correctement géré le cycle de vie, l’implémentation de tout ce code dépendant du cycle de vie dans vos méthodes de cycle de vie telles que les méthodes onStart () et onStop () était compliquée. En bref, cette approche rend les méthodes difficiles à lire, à maintenir et à tester.
Ainsi, la bibliothèque Lifecycle fournit une approche avancée de la gestion du cycle de vie en prenant en charge toutes les classes et interfaces nécessaires pour implémenter des composants sensibles au cycle de vie, qui ajustent leur comportement automatiquement et accomplissent même diverses actions en réponse aux événements du cycle de vie. De plus, rien ne garantit que le composant démarre avant l’arrêt de l’activité ou du fragment. Par exemple, si nous devons effectuer une tâche de longue durée comme une vérification de configuration dans onStart (). Cela peut conduire à une condition de concurrence critique où la méthode onStop () se termine avant onStart (). Cela signifie garder le composant en vie plus longtemps qu’il n’est nécessaire. Par exemple, supposons que nous ayons une activité qui représente l’emplacement du périphérique sur l’écran comme suit:
class MyActivity : AppCompatActivity() {
private lateinit var myLocationListener: MyLocationListener override fun onCreate(...) {
myLocationListener = MyLocationListener(this) { location ->
// update UI
}
} public override fun onStart() {
super.onStart()
Util.checkUserStatus { result ->
//If this callback is invoked after activity is stopped, what should we do?
if (result) {
myLocationListener.start()
}
}
} public override fun onStop() {
super.onStop()
myLocationListener.stop()
}}
Lcomposants compatibles ifecycle vous aider à gérer votre activité et à fragmenter les cycles de vie. Survivez aux changements de configuration, évitez les fuites de mémoire et chargez facilement les données dans votre interface utilisateur.
En fait, puisque ce processus est automatisé, Lifecycle vous aide à éviter certains problèmes causés par une mauvaise gestion du cycle de vie. En conséquence, votre code serait beaucoup plus organisé. et il serait plus facile à lire, à entretenir et à tester.
Quelle est la définition de la conscience du cycle de vie?
Un objet est mentionné pour être sensible au cycle de vie s’il est capable de détecter et de réagir aux changements de l’état du cycle de vie d’autres objets dans une application. Certains composants Android comme Données en direct sont déjà sensibles au cycle de vie. De plus, il est possible de configurer n’importe quelle classe pour qu’elle soit sensible au cycle de vie en implémentant le LifecycleObserver interface au sein de la classe.
Cycle de la vie
Initialement, Lifecycle est une classe abstraite à laquelle est associé un cycle de vie Android. Les objets peuvent observer cet état et agir de manière appropriée.
Cycle de la vie est une classe qui contient les informations sur l’état du cycle de vie d’un composant (comme une activité ou un fragment) et permet à d’autres objets d’observer cet état.
Pour garder une trace de cet état, deux concepts principaux sont représentés comme des énumérations: les événements et l’état.
En fait, dans le diagramme ci-dessus, les états sont des nœuds d’un graphe et les événements sont les bords entre ces nœuds. Fondamentalement, une classe peut surveiller l’état du cycle de vie du composant en utilisant des annotations dans ses méthodes. Par exemple:
class MyObserver : LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun connectListener() {
//...
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun disconnectListener() {
//...
}
}
En fait, le @OnLifecycleEvent l’annotation peut réagir aux événements de cycle de vie suivants:
- ON_CREATE
- ON_DESTROY
- ON_PAUSE
- POUR RÉSUMER
- ON_START
- ON_STOP
- ON_ANY
Remarque: La méthode attribuée au ON_ANY L’événement sera appelé pour tous les événements du cycle de vie.
Après cela, vous pouvez ajouter un observateur en appelant la méthode addObserver () de la classe Lifecycle et en passant une instance de votre observateur comme suit:
myLifecycleOwner.getLifecycle().addObserver(MyObserver())
Vous devez ajouter cette ligne de code dans votre méthode onCreate () de votre activité afin d’associer le LifecycleOwner au LifecycleObserver à l’aide de getLifecycle (). AddObserver ().
LifecycleOwner
Une interface implémentée par des objets avec un cycle de vie. Les fragments et les activités implémentent déjà l’interface LifecycleOwner dans la bibliothèque de support 26.1.0+ et sont par défaut LifecycleOwners. Les classes personnalisées peuvent également être configurées en tant que propriétaires de cycle de vie en utilisant le Cycle de vieRegistry et implémenter l’interface LifecycleObserver.
En outre, lorsque le statut d’un propriétaire de cycle de vie change, l’objet Lifecycle affecté sera mis à jour avec le nouvel état. À tout moment, un propriétaire de cycle de vie se trouvera dans l’un des cinq états suivants:
- Lifecycle.State.INITIALIZED
- Lifecycle.State.CREATED
- Lifecycle.State.STARTED
- Lifecycle.State.RESUMED
- Lifecycle.State.DESTROYED
Ainsi, la méthode isAtLeast () de l’objet état actuel peut également être utilisée lorsque l’état propriétaire doit se trouver à un certain stade du cycle de vie:
if(getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED)) { //...
}
Finalement, si vous essayez de gérer le cycle de vie d’un processus d’application entier, vous devez utiliser ProcessLifcyceOwner.
Quelques cas d’utilisation pour les composants sensibles au cycle de vie
En fait, les composants compatibles avec le cycle de vie peuvent vous faciliter la gestion des cycles de vie dans de nombreux cas. Par exemple:
- Arrêt et démarrage de la mise en mémoire tampon vidéo
- Démarrage et arrêt de la connectivité réseau.
- Pause et reprise des dessins animés.
Données en direct
De plus, la bibliothèque Lifecycle prend en charge la base de composants d’architecture Android supplémentaires, y compris LiveData. LiveData est un wrapper observable qui peut contenir toutes les données, y compris les listes. Une fois qu’une LiveData a une valeur, elle avertit ses observateurs affectés chaque fois que cette valeur change.
Données en direct est une classe de détenteurs de données observables. Contrairement à un observable normal, LiveData est sensible au cycle de vie, ce qui signifie qu’il respecte le cycle de vie des autres composants de l’application, tels que les activités, les fragments ou les services. Cette prise de conscience garantit que LiveData ne met à jour que les observateurs de composants d’application qui sont dans un état de cycle de vie actif.
Cependant, contrairement à un observable classique, LiveData est sensible au cycle de vie. Par conséquent, il ne met à jour que les observateurs qui sont dans un état «actif» tels que COMMENCÉ ou A REPRIS. Si le LifecycleOwner atteint un Lifecycle.State.DESTROYED état, alors le LiveData éliminera automatiquement l’observateur. Cette prise de conscience du cycle de vie vous aide à éviter les plantages qui peuvent se produire si vous essayez de mettre à jour une activité ou un fragment arrêté. Chaque fois qu’un composant entre dans le COMMENCÉ état, il reçoit automatiquement la valeur la plus récente de l’objet LiveData qu’il observe. Si une activité ou un fragment est repris ou recréé dans le cadre d’un processus de changement de configuration, il recevra les dernières données.
Quelques bonnes pratiques pour les composants sensibles au cycle de vie par Google
- Gardez vos contrôleurs d’interface utilisateur (activités et fragments) aussi légers que possible en utilisant LiveData et ViewModel
2. Mettez votre logique de données dans votre ViewModel classe. En fait, ViewModel devrait utiliser comme connecteur entre votre contrôleur d’interface utilisateur et le reste de votre application.
3. Utilisation Liaison de données pour maintenir une connexion nette entre vos vues et le contrôleur d’interface utilisateur.
4. Évitez de référencer un contexte de vue ou d’activité dans votre ViewModel.
En conclusion
Cet essai a considéré les composants Android Jetpack Lifecycle comme des classes avancées pour gérer les cycles de vie dans les applications Android. En fait, ces bibliothèques pourraient être utiles dans certains cas, comme l’arrêt et le démarrage de la mise en mémoire tampon vidéo, le démarrage et l’arrêt de la connectivité réseau, et la suspension et la reprise des dessins animés. De plus, vous pouvez utiliser LiveData comme une approche tenant compte du cycle de vie dans vos applications Android.
