TOMÁS GIRONÉS, JESÚS
Lista de acrónimos ................................................................................................ xv
¿Cómo leer este libro? ........................................................................................ xvii
CAPÍTULO 1. Diseño avanzado de interfaces de usuario .............................. 19
1.1.1 La clase Application ............................................................................. 21
1.1.2 Uso del patrón Singleton ..................................................................... 25
1.3.1 Insertar fragments desde XML ............................................................ 33
1.3.2 Insertar fragments desde código ......................................................... 41
1.3.3 Comunicación e intercambio de fragments ......................................... 42
1.4.1 La barra de acciones en versiones anteriores a la 3.0 ........................ 50
1.4.2 Añadiendo pestañas en la barra de acciones ..................................... 53
1.4.3 Añadiendo preferencias de usuario mediante
PreferenceFragment ............................................................................ 60
1.7.1 Animaciones de vistas: transiciones entre actividades ....................... 74
1.7.1.1 Aplicando animaciones de vistas en Audiolibros ...................... 77
1.7.2 Animaciones de propiedades .............................................................. 78
1.7.2.1 El motor básico de animación: ValueAnimator ......................... 79
1.7.2.2 Automatizando las animaciones: ObjectAnimator .................... 82
1.7.2.3 Combinando animaciones: AnimatorSet ................................... 83
1.7.2.4 Definiendo animaciones en XML .............................................. 83
1.7.2.5 Nuevas propiedades de la clase View ...................................... 86
1.7.2.6 Aplicando animaciones de propiedades en Audiolibros ........... 88
CAPÍTULO 2. Diseño personalizado de vistas ................................................. 91
2.2.1 Creación de escuchadores de eventos ............................................... 96
2.3.1 Algo más de información sobre TextView ......................................... 102
2.5.1 Diseño y dibujo de la vista ................................................................. 108
2.5.2 Gestión de eventos ............................................................................ 113
2.5.3 Cómo Android dibuja las vistas y obtiene sus tamaños .................... 116
2.5.4 Interactuando con otros objetos ........................................................ 119
2.6.1 Pasos a seguir para crear un widget ................................................. 120
2.6.1.1 Definir las características del widget ....................................... 121
2.6.1.2 Diseñar el layout del widget .................................................... 122
2.6.1.3 Crear una clase descendiente de AppWidgetProvider ........... 122
2.6.1.4 Declarar el widget en AndroidManifest ................................... 123
2.6.1.5 Crear una actividad para configurarlo ..................................... 123
2.6.2 Creación de un widget de escritorio sencillo ..................................... 124
2.6.3 Actualizando el widget de escritorio .................................................. 126
2.6.4 Actuando ante el evento onClick ....................................................... 128
2.6.5 Añadiendo una actividad de configuración ........................................ 130
CAPÍTULO 3. Hilos de ejecución en la interfaz del usuario .......................... 135
3.1.1 Cola de eventos y bucle de eventos.................................................. 137
3.1.2 El hilo de la interfaz de usuario de una aplicación Android ............... 138
3.2.1 Hilos para el manejo de eventos ....................................................... 141
3.2.2 El problema de los hilos en segundo plano: no tienen
acceso a la interfaz gráfica de usuario .............................................. 142
3.3.1 Extendiendo AsyncTask .................................................................... 144
3.3.2 Secuencia de operaciones ................................................................ 145
3.4.1 Llamando al método onDraw() .......................................................... 151
3.4.2 Programación con SurfaceViews ...................................................... 153
3.4.3 Estructura de la aplicación ................................................................ 154
CAPÍTULO 4. Comunicación con bluetooth ..................................................... 159
4.2.1 Emparejar dispositivos ...................................................................... 161
4.2.2 Transmisión de datos ........................................................................ 162
4.6.1 Consultar dispositivos vinculados ...................................................... 172
4.6.2 Descubriendo dispositivos ................................................................. 172
4.6.3 Habilitar Descubrimiento ................................................................... 173
4.7.1 Conexión como servidor .................................................................... 178
4.7.2 Conexión como cliente ...................................................................... 180
4.7.3 Gestión de la conexión ...................................................................... 182
4.7.3.1 Activando y desactivando el bluetooth en Android ................. 185
4.7.3.2 Descubriendo dispositivos ...................................................... 192
4.7.3.3 Creando el hilo de conexión.................................................... 198
4.7.3.4 Creando el hilo servidor .......................................................... 202
4.7.3.5 Creando el hilo cliente ............................................................. 204
CAPÍTULO 5. Servicios en la nube .................................................................... 211
5.1.1 Ventajas y desventajas de utilizar los servicios en la nube .............. 213
5.1.2 Servicios en la nube ofrecidos por Google ........................................ 214
5.1.2.1 Registrarse en los servicios en la nube de Google ................. 214
5.1.2.2 Servicios en la nube de Google .............................................. 215
5.2.1 Servicio Google Cloud Messaging .................................................... 219
5.2.2 Activar Google Cloud Messaging en Google API Console ............... 220
5.3.1 Usar Google Play Services en un proyecto ....................................... 222
5.3.2 Crear aplicación cliente GCM ............................................................ 225
5.3.3 Registrar dispositivo en GCM ............................................................ 230
5.3.4 Desregistrar dispositivo en GCM ....................................................... 233
5.3.5 Recepción de mensajes CGM en el dispositivo ................................ 235
5.3.6 Mostrar notificaciones en la barra de estado .................................... 237
5.5.1 Almacenamiento en Google Drive ..................................................... 247
5.5.2 Google Drive API v2 .......................................................................... 247
5.5.3 Crear una aplicación Android para Google Drive .............................. 250
5.5.3.1 Extracción de la huella digital (SHA1) ..................................... 251
5.5.3.2 Habilitar el servicio Google Drive API ..................................... 252
5.5.3.3 Autorizar el acceso a Google Drive ......................................... 253
5.5.3.4 Subir ficheros a Google Drive ................................................. 260
5.6.1 Fundamentos ..................................................................................... 265
5.6.2 Declaración del agente de copia de seguridad en Manifest ............. 266
5.6.3 Registro del servicio Android Backup ................................................ 266
5.6.4 BackupAgent ..................................................................................... 268
5.6.5 BackupAgentHelper ........................................................................... 268
5.6.5.1 Copia de seguridad de SharedPreferences ............................ 269
5.6.5.2 Copia de seguridad de archivos
de almacenamiento interno .................................................... 269
5.6.6 Comprobación de la versión al restaurar los datos ........................... 270
5.6.7 Solicitud de copia de seguridad y restauración ................................. 270
5.6.8 Un ejemplo paso a paso .................................................................... 270
CAPÍTULO 6. Aplicaciones web en Android ..................................................... 275
6.1.1 Una aplicación web de ejemplo: 3 en raya ........................................ 277
6.1.2 Aplicación web online y offline ........................................................... 283
6.2.1 Mostrar contenido web usando una intención ................................... 285
6.2.2 Uso de un WebView para mostrar contenido web ............................ 286
6.2.3 Aspectos básicos de un WebView .................................................... 288
6.2.3.1 Evitar el reinicio de la actividad ............................................... 288
6.2.3.2 Abrir los enlaces en el WebView ............................................. 289
6.2.3.3 Opciones de inicio ................................................................... 289
6.2.3.4 Barra de progreso ................................................................... 290
6.2.3.5 Navegación ............................................................................. 292
6.2.3.6 Controlar el botón «Volver» .................................................... 294
6.2.3.7 Capturar alertas JavaScript ..................................................... 295
6.2.3.8 Gestión de errores................................................................... 295
6.2.3.9 Descargas ............................................................................... 296
6.2.3.10 Conectividad ............................................................................ 298
6.3.1 Área de visualización y escalado ...................................................... 300
6.3.2 Escalado ............................................................................................ 302
6.3.3 Densidad de pantalla del dispositivo ................................................. 303
6.5.1 Phonegap .......................................................................................... 309
6.5.2 Jquery Mobile .................................................................................... 319
6.5.2.1 Crear una página básica ......................................................... 319
6.5.2.2 Añadir contenido ..................................................................... 321
6.5.2.3 Crear una lista ......................................................................... 322
6.5.2.4 Añadir un deslizador................................................................ 322
6.5.2.5 Crear un botón ........................................................................ 323
6.5.2.6 Temas ..................................................................................... 323
CAPÍTULO 7. Programación en código nativo ................................................. 327
7.1.1 Cuándo utilizar código nativo ............................................................ 329
7.1.2 Contenido de Android NDK ............................................................... 331
7.1.2.1 Las herramientas de desarrollo ............................................... 331
7.1.2.2 Documentación ....................................................................... 332
7.1.2.3 Aplicaciones de ejemplo ......................................................... 332
7.2.1 Instalación Android NDK en Windows ............................................... 333
7.2.2 Instalación Android NDK en Linux ..................................................... 337
7.2.3 Un primer ejemplo con Android NDK ................................................ 339
7.3.1 Desarrollo práctico de Android NDK .................................................. 343
7.3.2 Situación del código fuente nativo ..................................................... 343
7.3.2.1 Fichero Android.mk ................................................................. 344
7.3.2.2 Fichero Application.mk (opcional) ........................................... 346
7.3.2.3 La herramienta ndk-build ........................................................ 347
7.4.1 Librerías de enlace estático y dinámico ............................................ 350
7.4.2 Tipos fundamentales, referencias y arrays ....................................... 350
7.4.3 Desarrollo paso a paso de un programa mediante JNI (I) ................ 353
7.4.3.1 Declaración del método nativo y creación del archivo Android.
mk .................................................................................. 353
7.4.3.2 Creación del fichero de cabecera nativo ................................. 354
7.4.3.3 Implementación del método nativo ......................................... 355
7.4.3.4 Compilación del fichero nativo ................................................ 356
7.4.3.5 Ejecución de la aplicación ....................................................... 357
7.4.4 Acceso a métodos Java desde código nativo (JNI callback) ........... 358
7.4.4.1 Métodos de instancia .............................................................. 358
7.4.4.2 Métodos de clase .................................................................... 359
7.4.4.3 Invocar constructores .............................................................. 359
7.4.5 Excepciones ...................................................................................... 364
CAPÍTULO 8. Redes sociales: Facebook y Twitter .......................................... 377
8.1.1 Preliminares ....................................................................................... 378
8.1.1.1 Darse de alta en Facebook como desarrollador ..................... 378
8.1.1.2 SDK de Facebook para Android ............................................. 379
8.1.1.3 Configurando nuestra nueva aplicación .................................. 382
8.1.1.4 Sandbox mode ........................................................................ 384
8.1.1.5 Permisos para el App center ................................................... 385
8.1.1.6 Gestión de las aplicaciones instaladas en Facebook ............. 386
8.1.2 Nuestro proyecto Android .................................................................. 387
8.1.3 Aplicación de ejemplo ........................................................................ 390
8.2.1 Preliminares ....................................................................................... 401
8.2.2 Autentificación con Oauth .................................................................. 404
8.2.3 Configurando nuestra aplicación ....................................................... 405
8.2.4 Aplicación de ejemplo ........................................................................ 407
CAPÍTULO 9. Ingeniería inversa en An-droid ................................................... 419
9.2.1 La máquina virtual Dalvic .................................................................. 425
9.2.2 Decompilando aplicaciones Android ................................................. 427
9.3.1 Modificando recursos binarios de una aplicación .............................. 429
9.3.2 Modificando recursos XML de una aplicación ................................... 432
9.3.3 Modificando el código de una aplicación ........................................... 434
9.5.1 Cómo funciona el servicio de licencias ............................................. 443
9.5.2 Como añadir una licencia a nuestra aplicación ................................. 444
9.5.3 ¿Qué es una política de licencia? ..................................................... 451
9.6.1 Ingeniería inversa en una aplicación con licencia ............................. 453
9.6.2 Primera contramedida: ofuscar el código .......................................... 458
9.6.3 Segunda contramedida: no usar la librería LVL estándar ................. 461
El libro que tienes en sus manos es una guía para aquellos programadores de Android, que teniendo nociones básicas, quieran profundizar en algunos aspectos de especial interés. Diseño avanzado del interfaz de usuario: Aprenda todas las novedades incorporadas en las últimas versiones de Android: Fragments, ActionBar, Navigation Drawer, animación de propiedades Personalice sus propias vistas y cree Widgets de escritorio. Hilos de ejecución: En Android es imprescindible dominar el uso de threads. Use AsyncTask y programe animaciones gráficas con SurfaceView. Bluetooth: Saque provecho a esta tecnología para interconectar dos dispositivos Android, o un dispositivo Android con un PC. Servicios en la nube: Utilice en sus aplicaciones notificaciones Push (actualizado a la última versión), almacenamiento en la nube con Google Drive y el servicio de Backup de Google. Aplicaciones Web: Aprenda a integrar una aplicación basada en HTML5, CSS3 y JavaScript dentro de Android. Conozca las alternativas a la programación multiplataforma para móviles. Programación en código nativo: Use NDK para escribir directamente sus algoritmos en C/C++ y compílelos a código nativo del procesador. Redes sociales: Integre Facebook y Twitter en sus aplicaciones. Ingeniería inversa: Aprenda a jaquear aplicaciones para evitar que lo hagan con las suyas. Estudie el código y modifique aplicaciones de terceros. Ofusque el código e incluya licencias de Google Play para evitar usos no autorizados de su aplicación. El libro propone un aprendizaje activo, con actividades, muchas a través de Internet: vídeo[Tutorial]: Vídeos elaborados por los autores. Ejercicio paso a paso: La mejor forma de aprender es practicando. Práctica: Para afianzar lo aprendido hay que practicar. Recursos adicionales: Localice rápidamente la información clave. Preguntas de repaso y reflexión: ¿Lo ha entendido todo correctamente?
