El anuncio de
Android M, la nueva versión del sistema operativo móvil de Google, en Google I/O no fue tan relevante para los usuarios, pero sí lo fue para los desarrolladores. Y esto se debe a la presentación de una de sus herramientas, que podrá cambiar el futuro del desarrollo para esta plataforma. Su nombre es
Data Bindig.
Entre muchas cosas, el Data Binding nos permite dejar de preocuparnos por la actualización de las vistas cuando los datos cambian. Y para los que no se atreven con Android por culpa de Java, no hay que preocuparse,
con Data Binding se escribe muchísimo menos código Java.
Qué necesito para empezar
Para poder usar Data Binding
es necesario tener instalada la última versión de Android Studio 1.3. Además necesitaremos el preview del SDK de Android M, que se puede instalar desde el SDK Manager. Por último, es necesario contar con Android M. Es posible descargar una imagen de Android M para emularlo o actualizar tu Nexus con la preview.
Lo siguiente será configurar las dependencias del proyecto. Un nuevo proyecto de Android Studio tiene dos archivos
build.gradle. Uno pertenece al proyecto y el otro pertenece al módulo de la aplicación. Vamos a modificar primero el
gradle.build del proyecto.
[js]
buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:1.2.3'
classpath "com.android.tools.build:gradle:1.3.0-beta4"
classpath "com.android.databinding:dataBinder:1.0-rc1"
}
}
allprojects {
repositories {
jcenter()
}
}
[/js]
Pero también es necesario añadir la configuración necesaria al archivo
build.gradle del módulo, aplicando el plugin de Data Binding con el siguiente código:
Tampoco hay que olvidar que trabajamos sobre la preview del SDK de Android M.
[js]
apply plugin: 'com.android.application'
apply plugin: 'com.android.databinding'
[/js]
Tampoco hay que olvidar que trabajamos sobre
el preview del SDK de Android M.
[js]
compileSdkVersion 'android-MNC'
[/js]
[js]
minSdkVersion 'MNC'
targetSdkVersion 'MNC'
[/js]
El modelo
Antes que cualquier cosa, necesitaremos crear un modelo que usaremos en la aplicación. Este deberá contar con las siguientes características:
- Extender de BaseObservable
- Los getters de los atributos necesitan la anotación @Bindable
- En los setters deberemos notificar que los datos han cambiado con notifyPropertyChanged
[js]
public class User extends BaseObservable {
private String firstName;
public User(String firstName) {
this.firstName = firstName;
}
@Bindable
public String getFirstName() {
return this.firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
notifyPropertyChanged(com.stanete.databinding.BR.firstName);
}
}
[/js]
¿Y la interfaz?
Data Binding cambia la forma en la declaramos los layouts o vistas. Ahora debemos
especificar qué tipo de datos reciben las vistas y qué objeto va a proveer estos datos.
Por esta razón,
los layouts se componen de dos partes:
- Un parte en la que especificaremos las variables que usaremos
- Una segunda parte en la que declararemos las vistas
[js]
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
tools:context=".MainActivity">
<!-- Las variables que usaremos -->
<data>
<variable
name="user"
type="com.stanete.databinding.User" />
</data>
<!-- Las vistas -->
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.firstName}"
android:textSize="18sp" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:onClick="changeData"
android:text="HACER MAGIA" />
</LinearLayout>
</layout>
[/js]
El toque final
Aquí es cuando ocurre la magia de Data Binding. En la
Activity no vamos a hacer referencia a las vistas, Data Binding elimina eso por completo. Ya no encontraremos ningún
findViewById ni ningún
onClickListener.
Antes de seguir, es necesario hacer
Rebuild del proyecto.
La librería de Data Binding generará una clase Java por cada *bindable layout. El nombre de las clases Java se llamarán en función del nombre de tus vistas, añadiéndole el sufijo
Binding. De tal forma que, si tu layout se llama
activity_main.xml, la clase se llamará
ActivityMainBinding. Y esta clase será la que usaremos para enlazar los datos con las vistas.
Necesitamos añadir un par de líneas al código de la
Activity, para enlazar los datos con la vista. Aquí también añadiremos un método
changeData que se ejecute cuando hagamos click en un botón.
Y ¡voilá!
[js]
public class MainActivity extends AppCompatActivity {
User user;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ActivityMainBinding binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
user = new User("Freddy");
binding.setUser(user);
}
public void changeData(View view) {
user.setFirstName("Christian");
}
}
[/js]
Ya podemos ejecutar la aplicación en cualquier emulador o dispositivo con Android M. Al pulsar el botón los datos cambiarán, y como consecuencia, la vista se actualizará.
Data Binding nos permite crear aplicaciones Android de una manera más sencilla y rápida. Es una nueva forma de desarrollar Android, que cambia el paradigma de las arquitecturas actuales. Puedes descargar el repositorio de este tutorial en
GitHub.
Para aprender más sobre Data Bindig y otros temas que pueden convertirte en un mejor profesional del desarrollo en Android, te invito a que me acompañes el
lunes 10 de agosto a una clase gratuita que estaré impartiendo en la
comunidad de Platzi.
Y si quieres aprender más sobre desarrollo en Android, puedes registrarte al
curso de Android en Platzi, en el que aprenderás mucho más sobre la programación en el sistema operativo móvil más usado del mundo.
el link de
github[]((https://github.com/stanete/DataBindingExample/)
esta caido