Layoutansichten an Architekturkomponenten binden

Die AndroidX-Bibliothek enthält die Architekturkomponenten, mit denen Sie robuste, testbare und wartbare Apps entwickeln können. Die Datenbindung-Bibliothek funktioniert nahtlos mit den Architekturkomponenten, um die Entwicklung Ihrer Benutzeroberfläche weiter zu vereinfachen. Die Layouts in Ihrer App können an die Daten in den Architekturkomponenten gebunden werden. So können Sie den Lebenszyklus des UI-Controllers verwalten und die Benutzeroberfläche über Änderungen an den Daten informieren.

In diesem Dokument wird beschrieben, wie Sie die Architekturkomponenten in Ihre App einbinden, um die Datenbindung optimal zu nutzen.

LiveData verwenden, um die Benutzeroberfläche über Datenänderungen zu informieren

Sie können LiveData-Objekte als Datenbindungsquelle verwenden, um die Benutzeroberfläche automatisch über Änderungen an den Daten zu informieren. Weitere Informationen zu dieser Architekturkomponente finden Sie in der LiveData-Übersicht.

Im Gegensatz zu Objekten, die Observable implementieren, z. B. beobachtbare Felder, kennen LiveData-Objekte den Lebenszyklus der Beobachter, die die Datenänderungen abonniert haben. Dieses Wissen bietet viele Vorteile, die unter Vorteile der Verwendung von LiveData erläutert werden. In Android Studio ab Version 3.1 können Sie beobachtbare Felder in Ihrem Datenbindungscode durch LiveData-Objekte ersetzen.

Wenn Sie ein LiveData-Objekt mit Ihrer Bindungsklasse verwenden möchten, müssen Sie einen Lebenszyklusinhaber angeben, um den Bereich des LiveData-Objekts zu definieren. Im folgenden Beispiel wird die Aktivität als Lebenszyklusinhaber angegeben, nachdem die Bindungsklasse instanziiert wurde:

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

Sie können eine ViewModel-Komponente verwenden, wie im folgenden Abschnitt beschrieben, um die Daten an das Layout zu binden. In der ViewModel-Komponente können Sie das LiveData-Objekt verwenden, um die Daten zu transformieren oder mehrere Datenquellen zusammenzuführen. Im folgenden Beispiel wird gezeigt, wie die Daten in der ViewModel transformiert werden:

Kotlin

class ScheduleViewModel : ViewModel() {
    val userName: LiveData<String>

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

Java

class ScheduleViewModel extends ViewModel {
    LiveData<String> username;

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

ViewModel zum Verwalten von UI-bezogenen Daten verwenden

Die Datenbindung-Bibliothek funktioniert nahtlos mit ViewModel-Komponenten. ViewModel stellt die Daten bereit, die das Layout beobachtet und auf deren Änderungen es reagiert. Wenn Sie ViewModel-Komponenten mit der Data Binding Library verwenden, können Sie die UI-Logik aus den Layouts in die Komponenten verschieben, die sich leichter testen lassen. Die Datenbindung-Bibliothek sorgt dafür, dass die Ansichten bei Bedarf an die Datenquelle gebunden und von ihr getrennt werden. Der Großteil der verbleibenden Arbeit besteht darin, dafür zu sorgen, dass die richtigen Daten bereitgestellt werden. Weitere Informationen zu dieser Architekturkomponente finden Sie in der ViewModel-Übersicht.

Wenn Sie die ViewModel-Komponente mit der Datenbindung Library verwenden möchten, müssen Sie die Komponente instanziieren, die von der ViewModel-Klasse erbt, eine Instanz der Bindungsklasse abrufen und die ViewModel-Komponente einer Property in der Bindungsklasse zuweisen. Das folgende Beispiel zeigt, wie die Komponente mit der Bibliothek verwendet wird:

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

Weisen Sie in Ihrem Layout die Attribute und Methoden Ihrer ViewModel-Komponente den entsprechenden Ansichten mithilfe von Bindungsausdrücken zu, wie im folgenden Beispiel gezeigt:

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

Observable ViewModel für mehr Kontrolle über Bindungsadapter verwenden

Du kannst eine ViewModel-Komponente verwenden, die die Observable-Schnittstelle implementiert, um andere App-Komponenten über Änderungen an den Daten zu informieren, ähnlich wie du ein LiveData-Objekt verwenden würdest.

In manchen Situationen ist es möglicherweise besser, eine ViewModel-Komponente zu verwenden, die die Observable-Schnittstelle implementiert, anstatt LiveData-Objekte zu verwenden, auch wenn Sie die Funktionen zur Verwaltung des Lebenszyklus von LiveData verlieren. Wenn Sie eine ViewModel-Komponente verwenden, die Observable implementiert, haben Sie mehr Kontrolle über die Bindungsadapter in Ihrer App. Mit diesem Muster haben Sie beispielsweise mehr Kontrolle über die Benachrichtigungen, wenn sich Daten ändern. Außerdem können Sie eine benutzerdefinierte Methode angeben, um den Wert eines Attributs in der bidirektionalen Datenbindung festzulegen.

Wenn Sie eine beobachtbare ViewModel-Komponente implementieren möchten, müssen Sie eine Klasse erstellen, die von der Klasse ViewModel erbt und die Schnittstelle Observable implementiert. Sie können benutzerdefinierte Logik bereitstellen, wenn ein Beobachter Benachrichtigungen mit den Methoden addOnPropertyChangedCallback() und removeOnPropertyChangedCallback() abonniert oder abbestellt. Sie können auch eine benutzerdefinierte Logik bereitstellen, die ausgeführt wird, wenn sich Attribute in der Methode notifyPropertyChanged() ändern. Der folgende Beispielcode zeigt, wie ein beobachtbares ViewModel implementiert wird:

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

Zusätzliche Ressourcen

Weitere Informationen zur Datenbindung finden Sie in den folgenden zusätzlichen Ressourcen.