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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| 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() }} |
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.
1
2
| apply plugin: 'com.android.application'apply plugin: 'com.android.databinding' |
Tampoco hay que olvidar que trabajamos sobre el preview del SDK de Android M.
1
| compileSdkVersion 'android-MNC' |
1
2
| minSdkVersion 'MNC'targetSdkVersion 'MNC' |
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 connotifyPropertyChanged
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 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); }} |
¿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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| <layout xmlns:android="http://schemas.android.com/apk/res/android" 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> |
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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| 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"); }} |
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.
No hay comentarios:
Publicar un comentario