Comment ajouter View Binding à un projet Android Gradle

La plupart des développeurs Android connaissent probablement le classique findViewById() méthode. Transmettez-lui l'ID de l'une des vues de votre mise en page XML et il renverra une référence à la version gonflée de cette vue. Tout cela suppose que vous ayez transmis le bon identifiant et que la vue existe réellement. findViewById() n'a aucune vérification intégrée pour vous empêcher d'essayer de récupérer une vue que vous ne pouvez pas récupérer. Entrez la liaison de vue.

À la place d'utiliser findViewById() sur chaque vue souhaitée, View Binding génère automatiquement une classe de liaison pour chaque XML de mise en page. Chaque vue avec un ID est automatiquement ajoutée à la classe, vous pouvez donc les référencer directement.

L'ajout de View Binding à un projet Android Gradle est très simple.

Configuration progressive

View Binding est activé au niveau du module dans Gradle. Si vous disposez de plusieurs modules, vous devrez l'activer individuellement pour chacun.

Dans le android bloquer au niveau de votre module build.gradle, ajoutez l'option permettant d'activer la liaison de vue.

android {
 ...
 buildFeatures {
 viewBinding true
 }
}

Il peut y avoir un avertissement concernant un accès illégal, mais il s'agit d'un bug de charpie et peut être ignoré en toute sécurité.

Synchronisez le projet et View Binding sera activé. C'est si facile.

Utilisation de la liaison de vue

Il existe plusieurs façons d'utiliser View Binding, mais avant que cela se produise, parlons de la manière dont les classes de liaison sont générées.

Syntaxe du nom de classe

Supposons que vous ayez une mise en page XML nommée some_layout.xml. Sa classe de liaison correspondante sera nommée SomeLayoutBinding. Ce modèle est valable pour tous les fichiers.

Chaque mot (séparé par des traits de soulignement dans le nom du fichier) sera en majuscule et les traits de soulignement seront supprimés. "Binding" est ensuite ajouté à la fin.

Instanciation avec une vue existante

Si vous avez déjà gonflé le fichier de mise en page et que vous disposez d'une référence à la racine de la mise en page, vous pouvez indiquer à la classe de liaison View d'utiliser la mise en page existante.

Kotlin:

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

Java:

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

Par exemple, si vous souhaitez utiliser la classe de liaison dans un fragment, cela ressemblerait à ceci.

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.
 }
}

Java:

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);
 }
}

Instanciation avec une nouvelle vue

La classe de liaison peut également se charger de gonfler la mise en page pour vous.

Kotlin:

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

Java:

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

Cette méthode est utile à la fois dans les fragments et dans les activités.

Un exemple de fragment ressemblerait à quelque chose comme ceci.

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
 }
}

Java:

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 exemple d'activité ressemblerait à quelque chose comme ceci.

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)
 }
}

Java:

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());
 }
}

Référencement des vues

Maintenant que la classe de liaison View est configurée et prête à être utilisée, il est temps de l'utiliser réellement.

Disons que le contenu du some_layout.xml ressemblent à ceci :

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

Il existe de nombreux identifiants à référencer dans le code. Mais tant que la classe de liaison est instanciée, le référencement sera facile.

Dans Kotlin, les vues sont référencées par des variables correspondant à leurs identifiants, avec quelques modifications. Les traits de soulignement sont supprimés et la chaîne résultante est en casse chameau. Par exemple, pour faire référence some_frame_layout à partir du code, vous utiliseriez binding.someFrameLayout. Le someFrameLayout La variable sera une instance de FrameLayout.

val someFrameLayout: FrameLayout = binding.someFrameLayout

En Java, les vues sont référencées par des méthodes getter correspondant à leurs identifiants, avec un format similaire à Kotlin. Par exemple, pour faire référence some_frame_layout, tu utiliserais binding.getSomeFrameLayout(). La méthode renverra une instance de FrameLayout.

FrameLayout someFrameLayout = binding.getSomeFrameLayout();

Les références View sont également aplaties dans la liaison. Référencement inner_imageview est la même chose que le référencement some_frame_layout.

Conclusion

Comme vous pouvez le constater, View Binding dans Android est à la fois facile à mettre en œuvre et à utiliser. Dans de nombreux cas, il est plus facile à utiliser que findViewById().

Pour plus de détails sur la mise en œuvre de View Binding, ainsi que quelques exemples, consultez la documentation officielle de Google.