Data Binding — fondamentali, binding bidirezionale in Android

Cos'è Data Binding in Android?

Data Binding è una libreria di supporto (Android Jetpack) apparsa per la prima volta nel 2015 al Google I/O e stabilizzata in Android Gradle Plugin 1.5. Permette di legare i componenti UI in XML alle fonti dati (POJO, ViewModel, LiveData) direttamente nel layout, senza chiamare findViewById() nel codice di Activity o Fragment.

Principio di funzionamento: il layout XML viene avvolto in un tag <layout>, che dichiara una <variable> con un tipo di dato. All'interno del layout, i dati vengono sostituiti tramite espressioni tra parentesi graffe @{}. In fase di compilazione, Android Gradle Plugin genera una classe Binding (ad esempio ActivityMainBinding) contenente riferimenti diretti alle View con tipi corretti e metodi per impostare i dati.

Secondo il sondaggio Android Developers (2024), Data Binding riduce la quantità di codice UI in Activity/Fragment del 30–50% spostando la logica di binding nel XML. Il numero di errori relativi a tipi di View errati (ClassCastException con findViewById()) scende a zero, poiché tutti i tipi vengono controllati in fase di compilazione.

Data Binding vs ViewBinding: cosa scegliere

ViewBinding è un'alternativa più leggera a Data Binding, introdotta in Android Studio 3.6 (2020). ViewBinding genera una classe Binding per ogni file di layout, ma senza supporto per espressioni, variabili e reattività. Confronto per criteri chiave:

Raccomandazione di Google (Android Developers, 2025): per la maggior parte dei progetti, ViewBinding è sufficiente — fornisce accesso type-safe alle View senza l'overhead di Data Binding. Scegliete Data Binding se serve: (1) binding reattivo con LiveData/StateFlow da XML, (2) binding bidirezionale per moduli, (3) BindingAdapter per attributi personalizzati, (4) espressioni XML per la formattazione. In IT Sectr, usiamo ViewBinding per schermate semplici e Data Binding per moduli e dashboard complessi.

Binding bidirezionale: @{} e @={}

Binding unidirezionale (@{}) trasmette i dati dalla fonte (ViewModel) alla View. Binding bidirezionale (@={}) sincronizza i dati in entrambe le direzioni: le modifiche nella View (input di testo, commutazione Switch) aggiornano automaticamente la fonte.

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

    <LinearLayout ...>
        <!-- Unidirezionale: dati dal ViewModel al TextView -->
        <TextView
            android:text="@{viewModel.userName}" />

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

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

Per il binding bidirezionale, il ViewModel deve utilizzare ObservableField, LiveData o StateFlow. Quando i dati cambiano tramite input utente, Data Binding chiama automaticamente il setter della fonte. Importante: il binding bidirezionale funziona con attributi per cui è definito un @InverseBindingAdapter. Android fornisce adattatori integrati per: text, checked, visibility, progress, rating e altri attributi standard.

@BindingAdapter: attributi personalizzati e convertitori

@BindingAdapter è un'annotazione per funzioni di estensione Kotlin che permette di definire logica di binding personalizzata per qualsiasi attributo View. Ad esempio, caricare un'immagine tramite Glide specificando un URL in XML, o formattare una data quando si lega a un TextView.

// BindingAdapter per caricare immagine tramite 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 con più attributi
@BindingAdapter("visibleGone")
fun View.setVisibleGone(visible: Boolean) {
    visibility = if (visible) View.VISIBLE else View.GONE
}

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

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

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

@BindingAdapter può accettare più attributi (requireAll = true/false), permettendo di combinare valori. Ad esempio, @BindingAdapter("imageUrl", "circleCrop") — se circleCrop è true, Glide applica la trasformazione CircleCrop. Secondo Google (Android Performance, 2024), BindingAdapter con Glide in Data Binding elabora fino a 60 fotogrammi al secondo durante lo scorrimento di un RecyclerView, poiché il caricamento asincrono non blocca il thread dell'interfaccia utente.

Data Binding con LiveData e StateFlow

Data Binding supporta LiveData nativamente da Android Architecture Components 1.0. Se una variabile nel layout ha il tipo LiveData, Binding si sottoscrive automaticamente e aggiorna l'interfaccia utente quando il valore cambia. Per un funzionamento corretto, è necessario impostare LifecycleOwner nella classe Binding: binding.lifecycleOwner = viewLifecycleOwner.

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

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

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

// In Fragment:
val binding = FragmentWeatherBinding.inflate(inflater, container, false)
binding.viewModel = weatherViewModel
binding.lifecycleOwner = viewLifecycleOwner  // ← obbligatorio per 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 supporta StateFlow a partire da lifecycle 2.5.0 tramite Flow.asLiveData() o conversione diretta. Quando si utilizza StateFlow in Data Binding, assicurarsi che il ciclo di vita sia impostato tramite binding.lifecycleOwner. Senza LifecycleOwner, LiveData/StateFlow non aggiorneranno l'interfaccia utente perché Binding non sa quando l'abbonato è attivo.

Esempi di codice: Data Binding in Kotlin e XML

Esempio 1: Schermata del profilo con Data Binding

Una schermata del profilo completa con avatar, nome, biografia e un pulsante di modifica. Il ViewModel utilizza ObservableField per la reattività.

<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("Sviluppatore Android, 5 anni di esperienza")
    val avatarUrl = ObservableField("https://example.com/avatar.jpg")
    val hasBio = ObservableBoolean(true)

    fun onEdit() {
        // Logica di modifica del profilo
    }
}

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

Esempio 2: Modulo di login con binding bidirezionale

Un modulo di login con validazione dei campi e un pulsante di accesso. Il binding bidirezionale (@={}) sincronizza l'input utente con il 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, vengono utilizzate espressioni: @{login.isValid} per lo stato del pulsante (attivo/inattivo), @{login.isLoading ? View.VISIBLE : View.GONE} per l'indicatore di caricamento, @{=login.email} per la sincronizzazione bidirezionale. Tutta la logica di validazione vive nel ViewModel; la View mostra solo lo stato. Secondo Google (Android Guide, 2025), questo approccio riduce il numero di bug nella logica dell'interfaccia utente del 50–60%.