Lier les vues de disposition aux composants de l'architecture

La bibliothèque AndroidX comprend le module Architecture Composants, que vous pouvez pour concevoir des applications robustes, testables et faciles à gérer. La bibliothèque Data Binding fonctionne parfaitement avec l'architecture des composants pour simplifier le développement de votre UI. Les mises en page de votre application peut s'associer aux données des composants d'architecture, ce qui vous gérer le cycle de vie du contrôleur d'UI et informer l'UI des modifications apportées aux données.

Cette page explique comment intégrer les composants d'architecture à votre application pour exploiter au mieux la bibliothèque Data Binding.

Utiliser LiveData pour informer l'interface utilisateur des modifications de données

Vous pouvez utiliser des objets LiveData comme la source de liaison de données pour avertir automatiquement l'interface utilisateur des modifications apportées à données. Pour plus d'informations sur ce composant d'architecture, consultez la page LiveData présentation.

Contrairement aux objets qui implémentent Observable, par exemple observable : LiveData les objets connaissent le cycle de vie des observateurs abonnés aux données des modifications. Ces connaissances offrent de nombreux avantages, qui sont expliqués dans la section les avantages de l'utilisation LiveData : Dans Android Studio version 3.1 ou ultérieure, vous pouvez remplacer les champs observables. avec des objets LiveData dans votre code de liaison de données.

Pour utiliser un objet LiveData avec votre classe de liaison, vous devez spécifier une propriétaire du cycle de vie pour définir le champ d'application de l'objet LiveData. Les éléments suivants : "exemple" spécifie l'activité en tant que propriétaire du cycle de vie après la classe de liaison a été instanciée:

Kotlin

class ViewModelActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // Inflate view and obtain an instance of the binding class.
        val binding: UserBinding = DataBindingUtil.setContentView(this, R.layout.user)

        // Specify the current activity as the lifecycle owner.
        binding.setLifecycleOwner(this)
    }
}

Java

class ViewModelActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Inflate view and obtain an instance of the binding class.
        UserBinding binding = DataBindingUtil.setContentView(this, R.layout.user);

        // Specify the current activity as the lifecycle owner.
        binding.setLifecycleOwner(this);
    }
}

Vous pouvez utiliser un ViewModel , comme expliqué dans la section suivante, pour lier les données à la mise en page. Dans le composant ViewModel, vous pouvez utiliser l'objet LiveData pour transformer les données ou en fusionner plusieurs. sources. L'exemple suivant montre comment transformer les données dans ViewModel:

Kotlin

class ScheduleViewModel : ViewModel() {
    val userName: LiveData

    init {
        val result = Repository.userName
        userName = Transformations.map(result) { result -> result.value }
    }
}

Java

class ScheduleViewModel extends ViewModel {
    LiveData username;

    public ScheduleViewModel() {
        String result = Repository.userName;
        userName = Transformations.map(result, result -> result.value);
    }
}

Utiliser ViewModel pour gérer les données liées à l'UI

La bibliothèque Data Binding fonctionne parfaitement avec ViewModel. ViewModel expose les données que la mise en page observe et réagit à ses modifications. En utilisant Les composants ViewModel de la bibliothèque Data Binding vous permettent de déplacer la logique d'UI des mises en page et dans les composants, qui sont plus faciles à tester. Les données La bibliothèque de liaisons garantit que les vues sont liées et dissociées des données source si nécessaire. La majeure partie du travail restant consiste à s'assurer que vous présentez les bonnes données. Pour en savoir plus sur cette architecture, composant, consultez la page ViewModel présentation.

Pour utiliser le composant ViewModel avec la bibliothèque Data Binding, vous devez instanciez votre composant (qui hérite du paramètre ViewModel, obtenez une instance de votre classe de liaison et attribuez votre composant ViewModel à un dans la classe de liaison. L'exemple suivant montre comment utiliser la classe avec la bibliothèque:

Kotlin

class ViewModelActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // Obtain the ViewModel component.
        val userModel: UserModel by viewModels()

        // Inflate view and obtain an instance of the binding class.
        val binding: UserBinding = DataBindingUtil.setContentView(this, R.layout.user)

        // Assign the component to a property in the binding class.
        binding.viewmodel = userModel
    }
}

Java

class ViewModelActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Obtain the ViewModel component.
        UserModel userModel = new ViewModelProvider(this).get(UserModel.class);

        // Inflate view and obtain an instance of the binding class.
        UserBinding binding = DataBindingUtil.setContentView(this, R.layout.user);

        // Assign the component to a property in the binding class.
        binding.viewmodel = userModel;
    }
}

Dans la mise en page, attribuez les propriétés et les méthodes de votre composant ViewModel. aux vues correspondantes à l'aide d'expressions de liaison, comme illustré dans Exemple:

<CheckBox
    android:id="@+id/rememberMeCheckBox"
    android:checked="@{viewmodel.rememberMe}"
    android:onCheckedChanged="@{() -> viewmodel.rememberMeChanged()}" />

Utiliser un ViewModel observable pour mieux contrôler les adaptateurs de liaison

Vous pouvez utiliser un ViewModel qui implémente le composant Interface Observable pour avertir d'autres les composants de l'application sur les changements de données, de la même manière que vous utiliseriez LiveData.

Dans certains cas, il est préférable d'utiliser Composant ViewModel qui implémente Observable interface par rapport à l'utilisation d'objets LiveData, même si vous perdez le cycle de vie les fonctionnalités de gestion de LiveData. Utiliser un composant ViewModel qui implémente Observable, qui vous permet de mieux contrôler les adaptateurs de liaison dans votre l'application. Par exemple, ce schéma vous permet de mieux contrôler les notifications lorsque les données changent ; il vous permet également de spécifier une méthode personnalisée pour définir Valeur d'un attribut dans une liaison de données bidirectionnelle.

Pour implémenter un composant ViewModel observable, vous devez créer une classe qui hérite de la classe ViewModel et implémente Observable. de commande. Vous pouvez fournir une logique personnalisée lorsqu'un observateur s'abonne ou se désabonne des notifications à l'aide du addOnPropertyChangedCallback() et removeOnPropertyChangedCallback() méthodes. Vous pouvez également fournir une logique personnalisée qui s'exécute lorsque les propriétés changent dans la notifyPropertyChanged() . L'exemple de code suivant montre comment implémenter un objet ViewModel:

Kotlin

/**
 * A ViewModel that is also an Observable,
 * to be used with the Data Binding Library.
 */
open class ObservableViewModel : ViewModel(), Observable {
    private val callbacks: PropertyChangeRegistry = PropertyChangeRegistry()

    override fun addOnPropertyChangedCallback(
            callback: Observable.OnPropertyChangedCallback) {
        callbacks.add(callback)
    }

    override fun removeOnPropertyChangedCallback(
            callback: Observable.OnPropertyChangedCallback) {
        callbacks.remove(callback)
    }

    /**
     * Notifies observers that all properties of this instance have changed.
     */
    fun notifyChange() {
        callbacks.notifyCallbacks(this, 0, null)
    }

    /**
     * Notifies observers that a specific property has changed. The getter for the
     * property that changes must be marked with the @Bindable annotation to
     * generate a field in the BR class to be used as the fieldId parameter.
     *
     * @param fieldId The generated BR id for the Bindable field.
     */
    fun notifyPropertyChanged(fieldId: Int) {
        callbacks.notifyCallbacks(this, fieldId, null)
    }
}

Java

/**
 * A ViewModel that is also an Observable,
 * to be used with the Data Binding Library.
 */
class ObservableViewModel extends ViewModel implements Observable {
    private PropertyChangeRegistry callbacks = new PropertyChangeRegistry();

    @Override
    protected void addOnPropertyChangedCallback(
            Observable.OnPropertyChangedCallback callback) {
        callbacks.add(callback);
    }

    @Override
    protected void removeOnPropertyChangedCallback(
            Observable.OnPropertyChangedCallback callback) {
        callbacks.remove(callback);
    }

    /**
     * Notifies observers that all properties of this instance have changed.
     */
    void notifyChange() {
        callbacks.notifyCallbacks(this, 0, null);
    }

    /**
     * Notifies observers that a specific property has changed. The getter for the
     * property that changes must be marked with the @Bindable annotation to
     * generate a field in the BR class to be used as the fieldId parameter.
     *
     * @param fieldId The generated BR id for the Bindable field.
     */
    void notifyPropertyChanged(int fieldId) {
        callbacks.notifyCallbacks(this, fieldId, null);
    }
}

Ressources supplémentaires

Pour en savoir plus sur la liaison de données, consultez des ressources supplémentaires.