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.
Empfehlungen für Sie
- Hinweis: Der Linktext wird angezeigt, wenn JavaScript deaktiviert ist.
- Mit beobachtbaren Datenobjekten arbeiten
- Seitenweise Daten laden und anzeigen
- Kotlin-Koroutinen mit lebenszyklusbewussten Komponenten verwenden