Come aggiungere View Binding a un progetto Android Gradle

La maggior parte degli sviluppatori Android probabilmente ha familiarità con il classico findViewById() metodo. Passagli un ID di una delle viste nel tuo layout XML e restituirà un riferimento alla versione gonfiata di quella vista. Tutto ciò presuppone che tu abbia passato l'ID corretto e che la vista esista effettivamente. findViewById() non ha controlli integrati per impedirti di provare a recuperare una vista che non puoi recuperare. Immettere l'associazione della vista.

Invece di usare findViewById() su ogni vista desiderata, View Binding genera automaticamente una classe di associazione per ogni XML di layout. Ogni vista con un ID viene aggiunta automaticamente alla classe, quindi puoi farvi riferimento direttamente.

Aggiungere View Binding a un progetto Android Gradle è semplicissimo.

Configurazione del grado

View Binding è abilitato a livello di modulo in Gradle. Se disponi di più moduli, dovrai abilitarli individualmente per ciascuno di essi.

Nel android blocca a livello di modulo build.gradle, aggiungi l'opzione per abilitare l'associazione vista.

android {
 ...
 buildFeatures {
 viewBinding true
 }
}

Potrebbe esserci un avviso relativo all'accesso illegale, ma si tratta di un bug che non lascia residui e può essere tranquillamente ignorato.

Sincronizza il progetto e l'associazione vista sarà abilitata. È così facile.

Utilizzo dell'associazione della vista

Esistono alcuni modi per utilizzare View Binding, ma prima che ciò accada, parliamo di come vengono generate le classi di associazione.

Sintassi del nome della classe

Supponiamo che tu abbia un layout XML denominato some_layout.xml. Verrà denominata la classe di associazione corrispondente SomeLayoutBinding. Questo modello vale per tutti i file.

Ogni parola (separata da caratteri di sottolineatura nel nome del file) verrà scritta in maiuscolo e i caratteri di sottolineatura verranno rimossi. "Rilegatura" viene quindi aggiunto alla fine.

Istanziazione con vista esistente

Se hai già gonfiato il file di layout e hai un riferimento alla radice del layout, puoi dire alla classe di associazione View di utilizzare il layout esistente.

Kotlin:

val binding = SomeLayoutBinding.bind(someLayoutRoot /* should be a View instance */)

Giava:

SomeLayoutBinding binding = SomeLayoutBinding.bind(someLayoutRoot /* should be a View instance */);

Ad esempio, se volessi utilizzare la classe di associazione in un frammento, sarebbe simile a questo.

Kotlin:

classSomeFragment : Fragment(R.layout.some_layout) {
//Lazy initialization means bind() won't be called until "binding" is referenced.
private val binding by lazy { SomeLayoutBinding.bind(view) }
override fun onViewCreated(view: View, savedInstanceState: Bundle?){
super.onViewCreated(view, savedInstanceState)

//Once this method is called, you can start using the binding.
 }
}

Giava:

publicclassSomeFragmentextendsFragment{
private SomeLayoutBinding binding = null;
publicSomeFragment(){
super(R.layout.some_layout);
 }
@Override
publicvoidonViewCreated(View view, Bundle savedInstanceState){
super.onViewCreated(view, savedInstanceState);

//Initialize the binding.
 binding = SomeLayoutBinding.bind(view);
 }
}

Istanziazione con nuova vista

La classe di rilegatura può anche occuparsi di gonfiare il layout per te.

Kotlin:

val binding = SomeLayoutBinding.inflate(layoutInflater /* should be a LayoutInflater instance */)

Giava:

SomeLayoutBinding binding = SomeLayoutBinding.inflate(layoutInflater /* should be a LayoutInflater instance */);

Questo metodo è utile sia nei frammenti che nelle attività.

UN esempio Frammento sarebbe simile al seguente.

Kotlin:

classSomeFragment : Fragment() {
private val binding by lazy { SomeLayoutBinding.inflate(LayoutInflater.from(requireContext())) }
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?){
//The "root" of the binding class is the root of its layout.
return binding.root
 }
}

Giava:

publicclassSomeFragmentextendsFragment{
private SomeLayoutBinding binding = null;
@Override
publicvoidonCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState){
//Initialize the binding.
 binding = SomeLayoutBinding.inflate(inflater);
//The "getRoot()" method of the binding class returns the root of the layout.
return binding.getRoot();
 }
}

UN esempio di attività sarebbe simile al seguente.

Kotlin:

classSomeActivity : AppCompatActivity() {
private val binding by lazy { SomeLayoutBinding.inflate(layoutInflater) }
override fun onCreate(savedInstanceState: Bundle?){
super.onCreate(savedInstanceState)
//This is equivalent to calling "setContentView(R.layout.some_layout)" but allows use of the binding class.
setContentView(binding.root)
 }
}

Giava:

publicclassSomeActivityextendsAppCompatActivity{
private SomeLayoutBinding binding = null;
@Override
protectedvoidonCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
//Instantiate the binding.
 binding = SomeLayoutBinding.inflate(getLayoutInflater());
//This is equivalent to calling "setContentView(R.layout.some_layout)" but allows use of the binding class.
setContentView(binding.getRoot());
 }
}

Viste di riferimento

Ora che la classe di associazione View è configurata e pronta per l'uso, è il momento di utilizzarla effettivamente.

Diciamo il contenuto del some_layout.xml sono qualcosa come i seguenti:

 android:
 ...>
 android:
 ...
 />
 android:
 ...
 />
 android:
 ...>
 android:
 ...
 />
LinearLayout>
LinearLayout>

Ci sono molti ID a cui fare riferimento nel codice. Ma finché avrai istanziato la classe vincolante, fare riferimento sarà facile.

In Kotlin, le visualizzazioni fanno riferimento a variabili che corrispondono ai loro ID, con alcune modifiche. I caratteri di sottolineatura vengono rimossi e la stringa risultante ha il carattere di cammello. Ad esempio, per fare riferimento some_frame_layout dal codice, utilizzeresti binding.someFrameLayout. IL someFrameLayout la variabile sarà un'istanza di FrameLayout.

val someFrameLayout: FrameLayout = binding.someFrameLayout

In Java, le visualizzazioni vengono referenziate da metodi getter corrispondenti ai loro ID, con un formato simile a Kotlin. Ad esempio, per fare riferimento some_frame_layout, useresti binding.getSomeFrameLayout(). Il metodo restituirà un'istanza di FrameLayout.

FrameLayout someFrameLayout = binding.getSomeFrameLayout();

Anche i riferimenti View vengono appiattiti nell'associazione. Riferimento inner_imageview equivale a fare riferimento some_frame_layout.

Conclusione

Come sicuramente puoi vedere, View Binding in Android è facile da implementare e facile da usare. In molti casi, è più facile da usare rispetto a findViewById().

Per ulteriori dettagli sull'implementazione di View Binding, insieme ad alcuni esempi, controlla la documentazione ufficiale di Google.