View binding Parte di Android Jetpack.
La associazione delle visualizzazioni è una funzionalità che semplifica la scrittura di codice che interagisce con le visualizzazioni. Una volta attivata l'associazione delle visualizzazioni in un modulo, viene generata una classe di associazione per ogni file di layout XML presente nel modulo. Un'istanza di una classe di associazione contiene riferimenti diretti a tutte le visualizzazioni che hanno un ID nel layout corrispondente.
Nella maggior parte dei casi, l'associazione delle visualizzazioni sostituisce findViewById.
Configurazione
La visualizzazione dei binding è abilitata modulo per modulo. Per attivare l'associazione delle visualizzazioni in un modulo, imposta l'opzione di build viewBinding su true nel file build.gradle a livello di modulo, come mostrato nell'esempio seguente:
Alla moda
android { ... buildFeatures { viewBinding true } }
Kotlin
android { ... buildFeatures { viewBinding = true } }
Se vuoi che un file di layout venga ignorato durante la generazione delle classi di associazione, aggiungi l'attributo tools:viewBindingIgnore="true" alla visualizzazione principale del file di layout:
<LinearLayout
...
tools:viewBindingIgnore="true" >
...
</LinearLayout>
Utilizzo
Se l'associazione delle visualizzazioni è abilitata per un modulo, viene generata una classe di associazione per ogni file di layout XML contenuto nel modulo. Ogni classe di associazione contiene riferimenti alla visualizzazione principale e a tutte le visualizzazioni con un ID. Il nome della classe di associazione viene generato convertendo il nome del file XML in PascalCase e aggiungendo la parola "Binding" alla fine.
Ad esempio, considera un file di layout denominato result_profile.xml che contiene quanto segue:
<LinearLayout ... >
<TextView android:id="@+id/name" />
<ImageView android:cropToPadding="true" />
<Button android:id="@+id/button"
android:background="@drawable/rounded_button" />
</LinearLayout>
La classe di associazione generata si chiama ResultProfileBinding. Questa classe ha due campi: un TextView chiamato name e un Button chiamato button. ImageView nel layout non ha un ID, quindi non esiste alcun riferimento nella classe di associazione.
Ogni classe di associazione include anche un metodo getRoot(), che fornisce un riferimento diretto alla visualizzazione principale del file di layout corrispondente. In questo esempio, il metodo getRoot() nella classe ResultProfileBinding restituisce la visualizzazione principale LinearLayout.
Le sezioni seguenti mostrano l'utilizzo delle classi di associazione generate in attività e frammenti.
Utilizza l'associazione delle visualizzazioni nelle attività
Per configurare un'istanza della classe di associazione da utilizzare con un'attività, segui questi passaggi nel metodo onCreate() dell'attività:
- Chiama il metodo statico
inflate()incluso nella classe di associazione generata. In questo modo viene creata un'istanza della classe di associazione che l'attività può utilizzare. - Ottieni un riferimento alla visualizzazione principale chiamando il metodo
getRoot()o utilizzando la sintassi della proprietà Kotlin. - Passa la visualizzazione principale a
setContentView()per renderla la visualizzazione attiva sullo schermo.
Questi passaggi sono mostrati nell'esempio seguente:
Kotlin
private lateinit var binding: ResultProfileBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ResultProfileBinding.inflate(layoutInflater)
val view = binding.root
setContentView(view)
}
Java
private ResultProfileBinding binding;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
binding = ResultProfileBinding.inflate(getLayoutInflater());
View view = binding.getRoot();
setContentView(view);
}
Ora puoi utilizzare l'istanza della classe di associazione per fare riferimento a una qualsiasi delle visualizzazioni:
Kotlin
binding.name.text = viewModel.name
binding.button.setOnClickListener { viewModel.userClicked() }
Java
binding.name.setText(viewModel.getName());
binding.button.setOnClickListener(new View.OnClickListener() {
viewModel.userClicked()
});
Utilizza l'associazione delle visualizzazioni nei frammenti
Per configurare un'istanza della classe di associazione da utilizzare con un frammento, segui questi passaggi nel metodo onCreateView() del frammento:
- Chiama il metodo statico
inflate()incluso nella classe di associazione generata. In questo modo viene creata un'istanza della classe di associazione che il frammento può utilizzare. - Ottieni un riferimento alla visualizzazione principale chiamando il metodo
getRoot()o utilizzando la sintassi della proprietà Kotlin. - Restituisci la visualizzazione principale dal metodo
onCreateView()per renderla la visualizzazione attiva sullo schermo.
Kotlin
private var _binding: ResultProfileBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
_binding = ResultProfileBinding.inflate(inflater, container, false)
val view = binding.root
return view
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
Java
private ResultProfileBinding binding;
@Override
public View onCreateView (LayoutInflater inflater,
ViewGroup container,
Bundle savedInstanceState) {
binding = ResultProfileBinding.inflate(inflater, container, false);
View view = binding.getRoot();
return view;
}
@Override
public void onDestroyView() {
super.onDestroyView();
binding = null;
}
Ora puoi utilizzare l'istanza della classe di associazione per fare riferimento a una qualsiasi delle visualizzazioni:
Kotlin
binding.name.text = viewModel.name
binding.button.setOnClickListener { viewModel.userClicked() }
Java
binding.name.setText(viewModel.getName());
binding.button.setOnClickListener(new View.OnClickListener() {
viewModel.userClicked()
});
Fornisci suggerimenti per configurazioni diverse
Quando dichiari le visualizzazioni in più configurazioni, a volte è opportuno utilizzare un tipo di visualizzazione diverso a seconda del layout specifico. Il seguente snippet di codice mostra un esempio:
# in res/layout/example.xml
<TextView android:id="@+id/user_bio" />
# in res/layout-land/example.xml
<EditText android:id="@+id/user_bio" />
In questo caso, potresti aspettarti che la classe generata esponga un campo userBio
di tipo TextView, perché TextView è la classe base comune. A causa di limitazioni tecniche, il generatore di codice di View Binding non è in grado di determinarlo e genera invece un campo View. Ciò richiede l'esecuzione del cast del campo in un secondo momento con binding.userBio as TextView.
Per ovviare a questo limite, l'associazione delle visualizzazioni supporta un attributo tools:viewBindingType, che ti consente di indicare al compilatore il tipo da utilizzare nel codice generato.
Nell'esempio precedente, puoi utilizzare questo attributo per fare in modo che il compilatore generi il campo come TextView:
# in res/layout/example.xml (unchanged)
<TextView android:id="@+id/user_bio" />
# in res/layout-land/example.xml
<EditText android:id="@+id/user_bio" tools:viewBindingType="TextView" />
In un altro esempio, supponiamo di avere due layout, uno che contiene un BottomNavigationView e un altro che contiene un NavigationRailView. Entrambe le classi estendono NavigationBarView, che contiene la maggior parte dei dettagli di implementazione. Se il tuo codice non ha bisogno di sapere esattamente quale sottoclasse è presente nel layout corrente, puoi utilizzare tools:viewBindingType per impostare il tipo generato su NavigationBarView in entrambi i layout:
# in res/layout/navigation_example.xml
<BottomNavigationView android:id="@+id/navigation" tools:viewBindingType="NavigationBarView" />
# in res/layout-w720/navigation_example.xml
<NavigationRailView android:id="@+id/navigation" tools:viewBindingType="NavigationBarView" />
Il View Binding non può convalidare il valore di questo attributo durante la generazione del codice. Per evitare errori in fase di compilazione e di runtime, il valore deve soddisfare le seguenti condizioni:
- Il valore deve essere una classe che eredita da
android.view.View. Il valore deve essere una superclasse del tag su cui è posizionato. Ad esempio, i seguenti valori non funzionano:
<TextView tools:viewBindingType="ImageView" /> <!-- ImageView is not related to TextView. --> <TextView tools:viewBindingType="Button" /> <!-- Button is not a superclass of TextView. -->Il tipo finale deve essere risolto in modo coerente in tutte le configurazioni.
Differenze rispetto a findViewById
La visualizzazione dei binding presenta vantaggi importanti rispetto all'utilizzo di findViewById:
- Null safety: poiché l'associazione delle visualizzazioni crea riferimenti diretti alle visualizzazioni, non esiste il rischio di un'eccezione di puntatore nullo a causa di un ID visualizzazione non valido.
Inoltre, quando una visualizzazione è presente solo in alcune configurazioni di un layout, il campo contenente il relativo riferimento nella classe di associazione è contrassegnato con
@Nullable. - Sicurezza dei tipi: i campi di ogni classe di associazione hanno tipi corrispondenti alle visualizzazioni a cui fanno riferimento nel file XML. Ciò significa che non esiste il rischio di un'eccezione di class cast.
Queste differenze indicano che le incompatibilità tra il layout e il codice comportano un errore della build in tempo di compilazione anziché in fase di runtime.
Confronto con l'associazione di dati
L'associazione delle visualizzazioni e l'associazione di dati generano entrambe classi di associazione che puoi utilizzare per fare riferimento direttamente alle visualizzazioni. Tuttavia, l'associazione delle visualizzazioni è destinata a gestire casi d'uso più semplici e offre i seguenti vantaggi rispetto all'associazione di dati:
- Compilazione più rapida: il view binding non richiede l'elaborazione delle annotazioni, quindi i tempi di compilazione sono più rapidi.
- Facilità d'uso: il view binding non richiede file di layout XML con tag speciali, quindi è più veloce da adottare nelle tue app. Una volta attivata l'associazione delle visualizzazioni in un modulo, questa viene applicata automaticamente a tutti i layout del modulo.
D'altra parte, l'associazione delle visualizzazioni presenta le seguenti limitazioni rispetto all'associazione di dati:
- L'associazione delle visualizzazioni non supporta le variabili o le espressioni di layout, pertanto non può essere utilizzata per dichiarare contenuti dinamici dell'interfaccia utente direttamente dai file di layout XML.
- L'associazione delle visualizzazioni non supporta l'associazione di dati bidirezionale.
A causa di queste considerazioni, in alcuni casi è meglio utilizzare sia l'associazione di visualizzazioni sia l'associazione di dati in un progetto. Puoi utilizzare l'associazione di dati nei layout che richiedono funzionalità avanzate e l'associazione delle visualizzazioni nei layout che non le richiedono.
Risorse aggiuntive
Per scoprire di più sul view binding, consulta le seguenti risorse aggiuntive:
Blog
Video
Consigliati per te
- Nota: il testo del link viene visualizzato quando JavaScript è disattivato
- Esegui la migrazione da Kotlin Synthetics all'associazione di visualizzazioni di Jetpack
- Layout ed espressioni di associazione
- App Architecture: UI Layer - Get Started - Android Developers