Utilisation d’Android LiveData – Développement de logiciels
En tant que développeur Android, vous pouvez utiliser le concept ViewModel dans votre architecture pour communiquer entre différentes vues de votre application. Cependant, la situation pourrait être plus compliquée en raison d’un grand nombre de données ainsi que de la rotation de votre écran. En conséquence, Google a introduit le concept de LiveData dans le développement Android pour résoudre ces problèmes. En fait, LiveData est une classe de détenteurs de données observable, qui est également sensible au cycle de vie. Cet essai vise à discuter du concept de LiveData et à le mettre en œuvre avec ViewModel et Data Binding également.
Présentation et introduction
LiveData est une classe de détenteurs de données observables, qui est également sensible au cycle de vie. Par exemple, si vous avez votre interface utilisateur ainsi que l’objet LiveData qui contient des données que vous souhaitez afficher à l’écran. Dans ce cas, l’interface utilisateur observe l’objet LiveData. Cela signifie que l’interface utilisateur souhaite être notifiée pour les nouvelles mises à jour. Par conséquent, lorsque les LiveData changent, l’interface utilisateur est notifiée, puis l’interface utilisateur peut être en mesure de se redessiner avec les nouvelles données. En d’autres termes, LiveData facilite la synchronisation de ce qui se passe à l’écran avec les données. Cependant, LiveData vérifie l’état de l’observateur pour la première étape avant toute mise à jour.
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.
Ce qui différencie LiveData des autres approches observables, c’est qu’il tient également compte du cycle de vie. Cela signifie qu’il comprend si votre interface utilisateur est à l’écran, hors écran ou détruite. LiveData connaît votre état d’interface utilisateur, car vous l’avez transmis lorsque vous appelez Observe.
Implémentation de LiveData
Pour implémenter LiveData dans vos projets Android, vous devez suivre certaines étapes comme suit:
Création d’un objet LiveData dans la classe ViewModel
En fait, les objets LiveData seront généralement conservés dans la classe ViewModel et accessibles via une méthode getter. Ainsi, la première étape consiste à créer l’objet LiveData dans la classe ViewModel. De plus, LiveData est un wrapper qui peut être utilisé avec tous les types de données comme la liste.
class SampleViewModel : ViewModel() {// Create a LiveData with a String
val currentName: MutableLiveData by lazy {
MutableLiveData()
}
// Rest of the ViewModel...
}
Par exemple, si vous créez une activité et ViewModel pour un profil utilisateur, vous aurez cet objet LiveData utilisateur qui contient un objet User.
class UserViewModel: ViewModel() { private val _user MutableLiveData()
val user : LiveData}
get() = _user
Observer l’objet LiveData
Maintenant, dans la méthode onCreate de votre activité, vous obtiendrez ces LiveData de la classe ViewModel. Cela signifie que vous appelez observez sur le LiveData.
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)// Get the ViewModel
viewModel=ViewModelProviders.of(this).get(UserViewModel::class.java // Rest of the onCreate method...}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState) // Rest of the onCreate method...
// Creating the observer for updating the UI
val sampleObserver = Observer{ newName -> // Update the UI, in this example, a TextView.
sampleTextView.text = newName
} // Observe the LiveData
viewModel.currentName.observe(this, nameObserver)
}
Pour utiliser LiveData dans notre activité en même temps que le ViewModel, après avoir enregistré l’observateur dans l’activité, nous devons remplacer le onChanged () et vous définirez l’opération qui sera déclenchée en cas de modification des données.
Par conséquent, pour obtenir le formulaire d’objet LiveData ViewModel comme ci-dessus pour l’objet utilisateur, vous pouvez le faire dans la méthode onCreate comme suit:
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)userViewModel.user.observe(this, Observer { user ->
userNameTextView.text = user?.name})
}
Le premier argument est «ceci». Cela signifie que vous devez passer l’interface utilisateur, qui est une activité dans ce cas. En outre, le deuxième argument est un observateur, qui n’est qu’un rappel. Cependant, si vous utilisez la bibliothèque de liaison de données, vous n’aurez pas besoin de configurer manuellement ces observateurs. Ainsi, vous pouvez supprimer tout le passe-partout ci-dessus car le XML de TextView fait directement référence aux LiveData dans activity_main.xml comme ci-dessous:
...
android:text = "@{viewmodel.user.name}" /> En outre, vous devez définir la balise variable dans la mise en page de votre modèle de vue:
name="viewmodel"
type="android.example.com.UserViewModel"/>
<.../>
En fait, si vous utilisez Android studio 3.1 ou supérieur, LiveData et ViewModel fonctionnent avec Data Binding.
ViewModel + LiveData + liaison de données = interface utilisateur réactive
Fondamentalement, après avoir associé votre disposition ViewModel et Data Binding dans la méthode onCreate () via la méthode de liaison et de gonflement, il vous suffit d’ajouter cette disposition de changement de ligne unique. En d’autres termes, vous devez ajouter ce changement de ligne unique pour que vos LiveData soient correctement observés lorsqu’ils sont liés au XML.
binding.setLifecycleOwner(this)
En bref, c’est la magie qui permet à la liaison de se mettre à jour à chaque mise à jour de LiveData et à l’écran de ViewModel. Par conséquent, si votre activité n’est pas à l’écran, votre LiveData ne déclenche pas de mises à jour inutiles de l’interface utilisateur. Cela signifie que si l’activité ou l’interface utilisateur est détruite, la connexion d’observation est nettoyée automatiquement par LiveData. Ainsi, vous ne déclencherez jamais accidentellement une activité ou un fragment hors écran ou détruit pour se redessiner. Cela est possible en raison des interfaces et des classes de la bibliothèque Lifecycle qui sont également utilisées par les classes d’infrastructure. Ces classes sont les suivantes: Cycle de la vie, LifecycleOwner, et LifecycleObserver.
- Cycle de la vie: est un objet qui définit le cycle de vie Android et son état.
2. LifecycleOwner: est une interface pour les objets, qui ont un cycle de vie comme AppCompatActvity ou Activity or Fragment
3. LifecycleObserver: est une interface pour observer un cycle de vie.
Mise à jour de l’objet LiveData
Dans cette étape, nous devons mettre à jour l’objet du LiveData. A cet effet, vous pouvez soit utiliser le setValue (T) ou la méthode postValue (T) de la classe MutableLiveData. La raison de l’utilisation de la classe MutableLiveData uniquement est que le LiveData n’a pas de méthodes publiques pour mettre à jour la valeur stockée. Par conséquent, nous devons utiliser la classe MutableLiveData. Par exemple, il déclenche tous les observateurs lorsque nous appuyons sur un bouton. Alors le onChanged () sera appelée lorsque nous appuierons sur le bouton, et la valeur de cette méthode contiendra Android LiveData.
button.setOnClickListener { val sampleName = "Android LiveData"
model.currentName.setValue(sampleName)}
Utilisez setValue si vous exécutez sur le thread d’interface utilisateur, puis utilisez postValue si vous exécutez sur un thread d’arrière-plan. Par conséquent, lorsque setValue ou postValue est appelé, le LiveData notifie les observateurs actifs.
Extension de LiveData
Comme vous le savez, vous pouvez utiliser LiveData uniquement et mettre à jour les modifications lorsque l’observateur est en état actif. LiveData considère qu’un observateur est dans un état actif si le cycle de vie de l’observateur est dans les états STARTED ou RESUMED. Ainsi, vous pouvez étendre la classe LiveData dans votre classe d’observateur et remplacer le onActive () et onInactive () méthode. Cette méthode onActive () sera utilisée pour vérifier s’il y a un changement dans LiveData ou non. En outre, la méthode onInactive () est utilisée pour supprimer les mises à jour.
Transformer LiveData
Initialement, vous souhaiterez peut-être apporter des modifications à la valeur stockée dans un objet LiveData avant de le distribuer aux observateurs, ou vous devrez peut-être renvoyer une autre instance LiveData. le Forfait cycle de vie prend en charge la classe Transformation qui contient des méthodes d’assistance, qui fournissent ces approches.
carte(): vous permet d’appliquer une fonction à la sortie de LiveData, puis de propager le résultat vers l’aval. Par exemple, dans un scénario où nous devons afficher Snackbar chaque fois qu’un nouvel utilisateur s’ajoute à la base de données. La Snackbar affiche les données d’une chaîne personnalisée avec un nom d’utilisateur ajouté.
switchMap (): cette transformation de fonction est similaire à map, mais pour les fonctions de mapping qui émettent LiveData au lieu des valeurs utilisées. Par exemple, si vous avez un groupe d’utilisateurs, probablement stocké dans une base de données Room, vous pouvez avoir une fonction de recherche pour ces utilisateurs. En utilisant switchMap (), vous aurez un LiveData pour l’ID utilisateur. Chaque fois que l’ID change, votre fonction de recherche d’utilisateur est appelée avec cet ID. En d’autres termes, quel que soit le nombre de fois où vous appelez cette fonction de recherche et obtenez un LiveData différent, votre interface utilisateur n’a besoin d’observer le résultat LiveData qu’une seule fois, ce qui est la puissance de switchMap. Le switchMap les fonctions propagent LiveData vers l’aval au lieu d’une valeur unique. Un autre exemple où vous devez rechercher l’utilisateur par nom d’utilisateur et afficher le résultat dans RecyclerView.
MediatorLiveData (): si vous souhaitez créer vos propres transformations de données personnalisées, vous devez considérer la classe MediatorLiveData. MediatorLiveData comprend des méthodes pour ajouter et supprimer des objets LiveData source. Ainsi, vous pouvez combiner et propager des événements de toutes ces sources en aval.
Quelques avantages de LiveData
- Une mise à jour appropriée dans l’interface utilisateur: À l’aide de LiveData, l’interface utilisateur de votre application ne sera modifiée qu’en cas de modification des données.
- Pas de plantage à cause d’activités interrompues: Seul cet observateur sera averti qu’il est en état réel. Ainsi, un plantage de l’application ne se produira pas en raison d’activités arrêtées ou suspendues.
- Modifications de configuration appropriées: Si une activité ou un fragment est recréé en raison d’un changement de configuration comme la rotation de l’appareil, il reçoit immédiatement le dernier état.
- Données à jour: L’observateur disposera des dernières données même s’il est en arrière-plan ou en pause. À chaque reprise de l’observateur, les dernières données mises à jour lui seront fournies.
- Aucune fuite de mémoire: Étant donné que tous les observateurs sont liés aux objets du cycle de vie et sont nettoyés lorsque leur cycle de vie associé est détruit, il n’y a aucune fuite de mémoire.
En conclusion
En fait, LiveData est utilisé pour avertir l’utilisateur s’il y a un changement dans la valeur des objets de LiveData. Dans cet essai, nous avons examiné le concept de LiveData et l’avons également implémenté avec ViewModel et Data Binding. De plus, nous avons remarqué que ce concept a des conséquences positives pour la gestion des données sur View dans certaines situations spéciales comme les rotations d’écran. qui joue un rôle clé dans le maintien et la mise à jour des états des objets.
