Data Binding — Grundlagen, bidirektionale Bindung in Android

Was ist Data Binding in Android?

Data Binding ist eine Support-Bibliothek (Android Jetpack), die erstmals 2015 auf der Google I/O vorgestellt und in Android Gradle Plugin 1.5 stabilisiert wurde. Sie ermöglicht es, UI-Komponenten in XML direkt im Layout an Datenquellen (POJO, ViewModel, LiveData) zu binden, ohne findViewById() im Activity- oder Fragment-Code aufzurufen.

Funktionsweise: Das XML-Layout wird in ein <layout>-Tag gewickelt, das eine <variable> mit einem Datentyp deklariert. Innerhalb des Layouts werden Daten durch Ausdrücke in geschweiften Klammern @{} eingesetzt. Zur Kompilierzeit generiert das Android Gradle Plugin eine Binding-Klasse (z.B. ActivityMainBinding) mit direkten Verweisen auf Views mit korrekten Typen und Methoden zum Setzen von Daten.

Laut der Android Developers-Umfrage (2024) reduziert Data Binding die Menge an UI-Code in Activity/Fragment um 30–50%, indem die Bindungslogik ins XML verlagert wird. Die Anzahl der Fehler durch falsche View-Typen (ClassCastException bei findViewById()) sinkt auf null, da alle Typen zur Kompilierzeit geprüft werden.

Data Binding vs ViewBinding: Was wählen

ViewBinding ist eine leichtere Alternative zu Data Binding, eingeführt in Android Studio 3.6 (2020). ViewBinding generiert eine Binding-Klasse für jede Layout-Datei, jedoch ohne Unterstützung für Ausdrücke, Variablen und Reaktivität. Vergleich nach Schlüsselkriterien:

Googles Empfehlung (Android Developers, 2025): Für die meisten Projekte ist ViewBinding ausreichend — es bietet typsicheren Zugriff auf Views ohne den Overhead von Data Binding. Wählen Sie Data Binding, wenn Sie benötigen: (1) reaktive Bindung mit LiveData/StateFlow aus XML, (2) bidirektionale Bindung für Formulare, (3) BindingAdapter für benutzerdefinierte Attribute, (4) XML-Ausdrücke für die Formatierung. Bei IT Sectr verwenden wir ViewBinding für einfache Bildschirme und Data Binding für komplexe Formulare und Dashboards.

Bidirektionale Bindung: @{} und @={}

Unidirektionale Bindung (@{}) übergibt Daten von der Quelle (ViewModel) an die View. Bidirektionale Bindung (@={}) synchronisiert Daten in beide Richtungen: Änderungen in der View (Texteingabe, Switch-Umschaltung) aktualisieren automatisch die Quelle.

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.example.app.LoginViewModel" />
    </data>

    <LinearLayout ...>
        <!-- Unidirektional: Daten vom ViewModel zum TextView -->
        <TextView
            android:text="@{viewModel.userName}" />

        <!-- Bidirektional: EditText-Änderungen → ViewModel, ViewModel → EditText -->
        <EditText
            android:text="@{=viewModel.email}" />

        <CheckBox
            android:checked="@{=viewModel.agreeToTerms}" />
    </LinearLayout>
</layout>

Für die bidirektionale Bindung muss das ViewModel ObservableField, LiveData oder StateFlow verwenden. Wenn sich Daten durch Benutzereingabe ändern, ruft Data Binding automatisch den Setter der Quelle auf. Wichtig: Die bidirektionale Bindung funktioniert mit Attributen, für die ein @InverseBindingAdapter definiert ist. Android bietet integrierte Adapter für: text, checked, visibility, progress, rating und andere Standardattribute.

@BindingAdapter: Benutzerdefinierte Attribute und Konverter

@BindingAdapter ist eine Annotation für Kotlin-Erweiterungsfunktionen, die es ermöglicht, benutzerdefinierte Bindungslogik für jedes View-Attribut zu definieren. Zum Beispiel das Laden eines Bildes über Glide bei Angabe einer URL in XML oder das Formatieren eines Datums bei Bindung an ein TextView.

// BindingAdapter zum Laden von Bildern per URL
@BindingAdapter("imageUrl")
fun ImageView.setImageUrl(url: String?) {
    Glide.with(this.context)
        .load(url)
        .placeholder(R.drawable.placeholder)
        .error(R.drawable.error)
        .into(this)
}

// BindingAdapter mit mehreren Attributen
@BindingAdapter("visibleGone")
fun View.setVisibleGone(visible: Boolean) {
    visibility = if (visible) View.VISIBLE else View.GONE
}

// BindingAdapter mit Konverter (formatDate)
@BindingAdapter("formattedDate")
fun TextView.setFormattedDate(timestamp: Long) {
    text = SimpleDateFormat("dd.MM.yyyy", Locale.getDefault()).format(Date(timestamp))
}

<!-- BindingAdapter in XML verwenden -->
<ImageView
    imageUrl="@{user.avatarUrl}"
    android:layout_width="48dp"
    android:layout_height="48dp" />

<TextView
    formattedDate="@{message.createdAt}"
    visibleGone="@{message.isVisible}" />

@BindingAdapter kann mehrere Attribute akzeptieren (requireAll = true/false), was die Kombination von Werten ermöglicht. Zum Beispiel @BindingAdapter("imageUrl", "circleCrop") — wenn circleCrop true ist, wendet Glide die CircleCrop-Transformation an. Laut Google (Android Performance, 2024) verarbeitet BindingAdapter mit Glide in Data Binding bis zu 60 Bilder pro Sekunde beim Scrollen eines RecyclerView, da das asynchrone Laden den UI-Thread nicht blockiert.

Data Binding mit LiveData und StateFlow

Data Binding unterstützt LiveData nativ seit Android Architecture Components 1.0. Wenn eine Variable im Layout den Typ LiveData hat, abonniert Binding diese automatisch und aktualisiert die UI bei Wertänderungen. Für den korrekten Betrieb muss der LifecycleOwner in der Binding-Klasse gesetzt werden: binding.lifecycleOwner = viewLifecycleOwner.

// ViewModel mit LiveData
class WeatherViewModel : ViewModel() {
    private val _temperature = MutableLiveData("--")
    val temperature: LiveData<String> get() = _temperature

    val cityName = MutableLiveData("Moskau")
    val weatherIcon = MutableLiveData(R.drawable.ic_sunny)

    fun refresh() {
        viewModelScope.launch {
            _temperature.value = weatherRepository.getTemperature()
        }
    }
}

// Im Fragment:
val binding = FragmentWeatherBinding.inflate(inflater, container, false)
binding.viewModel = weatherViewModel
binding.lifecycleOwner = viewLifecycleOwner  // ← erforderlich für LiveData

<layout>
    <data>
        <variable name="viewModel" type="com.example.app.WeatherViewModel" />
    </data>

    <LinearLayout ...>
        <TextView
            android:text="@string/temperature_format(viewModel.temperature)" />
        <TextView android:text="@{viewModel.cityName}" />
        <ImageView
            android:src="@{viewModel.weatherIcon}"
            contentDescription="@{viewModel.cityName}" />
    </LinearLayout>
</layout>

Data Binding unterstützt StateFlow ab lifecycle 2.5.0 über Flow.asLiveData() oder direkte Konvertierung. Bei Verwendung von StateFlow in Data Binding stellen Sie sicher, dass der Lebenszyklus über binding.lifecycleOwner gesetzt ist. Ohne LifecycleOwner werden LiveData/StateFlow die UI nicht aktualisieren, da Binding nicht weiß, wann der Abonnent aktiv ist.

Codebeispiele: Data Binding in Kotlin und XML

Beispiel 1: Profilbildschirm mit Data Binding

Ein vollständiger Profilbildschirm mit Avatar, Name, Biografie und einem Bearbeitungsbutton. Das ViewModel verwendet ObservableField für Reaktivität.

<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <data>
        <variable name="profile" type="com.example.app.ProfileViewModel" />
    </data>

    <androidx.constraintlayout...>
        <ImageView
            app:imageUrl="@{profile.avatarUrl}"
            android:contentDescription="@{profile.name}" />

        <TextView
            android:text="@{profile.name}"
            android:textStyle="bold" />

        <TextView
            android:text="@{profile.bio}"
            android:visibility="@{profile.hasBio ? View.VISIBLE : View.GONE}" />

        <Button
            android:onClick="@{() -> profile.onEdit()}"
            android:text="@string/edit" />
    </androidx.constraintlayout...>
</layout>

class ProfileViewModel : ViewModel() {
    val name = ObservableField("Anna Petrova")
    val bio = ObservableField("Android-Entwickler, 5 Jahre Erfahrung")
    val avatarUrl = ObservableField("https://example.com/avatar.jpg")
    val hasBio = ObservableBoolean(true)

    fun onEdit() {
        // Profileditierungslogik
    }
}

// Im Fragment:
val binding = FragmentProfileBinding.inflate(inflater, container, false)
binding.profile = profileViewModel
binding.lifecycleOwner = viewLifecycleOwner

Beispiel 2: Login-Formular mit bidirektionaler Bindung

Ein Login-Formular mit Feldvalidierung und einem Login-Button. Die bidirektionale Bindung (@={}) synchronisiert die Benutzereingabe mit dem ViewModel.

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable name="login" type="com.example.app.LoginViewModel" />
    </data>

    <LinearLayout ...>
        <TextInputLayout>
            <TextInputEditText
                android:text="@{=login.email}"
                android:hint="@string/email_hint" />
        </TextInputLayout>

        <TextInputLayout>
            <TextInputEditText
                android:text="@{=login.password}"
                android:inputType="textPassword" />
        </TextInputLayout>

        <Button
            android:onClick="@{() -> login.onLogin()}"
            android:enabled="@{login.isValid}"
            android:text="@string/login" />

        <ProgressBar
            android:visibility="@{login.isLoading ? View.VISIBLE : View.GONE}" />
    </LinearLayout>
</layout>

In XML werden Ausdrücke verwendet: @{login.isValid} für den Button-Status (aktiv/inaktiv), @{login.isLoading ? View.VISIBLE : View.GONE} für den Ladeindikator, @{=login.email} für die bidirektionale Synchronisation. Die gesamte Validierungslogik lebt im ViewModel; die View zeigt nur den Zustand an. Laut Google (Android Guide, 2025) reduziert dieser Ansatz die Anzahl der UI-Logikfehler um 50–60%.