Android Estudio de Desarrollo de Essentials

Android estudio de desarrollo de Essentials
Indice
1_La creación de un equipo con Windows, Linux o Mac OS X Android Ambiente Development
Studio
Requisitos del sistema

Instalación del Java Development Kit (JDK)
Instalación de Windows JDK
La instalación de Mac OS X JDK
Instalación de Linux JDK
La descarga del paquete Android Estudio
Instalar Android Estudio
La instalación en Windows
Instalación en Mac OS X
Instalación en Linux
Instalación de los últimos paquetes SDK de Android
Hacer las herramientas del SDK de línea de comandos Android Accesible
Windows 7
De Windows 8.1
Linux
Mac OS X
Actualización del Estudio de Android y el SDK
2 Creación de una aplicación Android en Android Ejemplo Estudio

Creación de un nuevo proyecto de Android
Definición de la configuración del proyecto y SDK
La comprensión de los ajustes del modo de Apoyo
Configuración del icono Launcher
Creación de una actividad
Modificación del ejemplo de aplicación
La revisión de los archivos de diseño y Recursos
Vista previa de la Disposición
3
Un recorrido por la interfaz de usuario de Android Estudio
La pantalla de bienvenida
La ventana principal
La herramienta de Windows
Atajos de teclado Android Studio
Switcher y archivos recientes Navegación
Cambiar el tema Android Estudio
4
Creación de un dispositivo virtual de Android (AVD) en Android Estudio
Acerca de los dispositivos virtuales de Android
Creación de una nueva AVD
Inicio del emulador
Ejecutar la aplicación en la AVD
Ejecutar / depurar Configuraciones
Detener una aplicación en ejecución
De línea de comandos AVD Creación
Archivos de configuración de dispositivos virtuales de Android
Mover y Cambiar el nombre de un dispositivo virtual de Android
5
Prueba Android Apps Estudio en un dispositivo Android Física
Una visión general del Android depuración Bridge (ADB)
Habilitación de ADB en Android 4.4 dispositivos basados
Mac OS X configuración ADB
Configuración de Windows ADB
Prueba de la conexión adb
6
Los fundamentos de la Android Studio Editor Código
El Android Studio Editor
La división de la ventana del editor
Código de finalización
Finalización de instrucciones
Información de parámetros
Generación de código
Plegable Código
Búsqueda de Documentación Rápida
Código El cambio de formato
7
Una visión general de la arquitectura de Android
El Android Software Stack
El kernel de Linux
Runtime Android - Dalvik Virtual Machine
Runtime Android - Bibliotecas Core
Dalvik VM Bibliotecas específicas
Java interoperabilidad Bibliotecas
Bibliotecas Android
C / C ++ Bibliotecas
Application Framework
Aplicaciones
8
La Anatomía de una aplicación Android Android Estudio
Actividades Android
Intenciones Android
Broadcast Intenciones
Receptores de radiodifusión
Servicios para Android
Proveedores de Contenido
El Manifiesto de la aplicación
De recursos de aplicaciones
Contexto de aplicación
9
Entender Aplicación para Android y Actividad Lifecycles
Aplicaciones para Android y Gestión de Recursos
Estados Proceso Android
Proceso de primer plano
Proceso Visible
Proceso de Servicio
Proceso de fondo
Proceso de vacío
Dependencias entre procesos
El Ciclo de Vida de Actividad
La Actividad Pila
Actividad Unidos
Los cambios de configuración
Manipulación de cambio de estado
10
Manipulación Android Actividad Cambios de estado en Android Estudio
La actividad de la clase
Estado Dinamizador vs. Estado Persistente
Los métodos de ciclo de vida para Android Actividad
Vidas Actividad
11
Android Actividad Estado Cambios - Un Estudio Android Ejemplo
Crear el Ejemplo de proyecto de cambio de estado
El diseño de la interfaz de usuario
Anulación de los métodos de ciclo de vida de actividad
Filtrar el Panel LogCat
Ejecutar la aplicación
Experimentar con la Actividad
12
Guardar y restaurar la actividad del Estado en Android Estudio
Ahorrar Estado Dinamizador
Guardado predeterminado de la interfaz de usuario del Estado
La Clase Bundle
Guardar el Estado
Restauración del Estado
Prueba de la aplicación
13
Entendiendo Vistas Android, Ver grupos y diseños en Android Estudio
Diseñar para diferentes dispositivos Android
Vistas y Ver grupos
Android Controladores de Distribución
La vista Jerarquía
La creación de interfaces de usuario
14
Una guía para la herramienta Diseñador Android Estudio
El Diseñador Android Estudio
Modo de diseño
Modo de texto
Configuración de las propiedades
Tipo Morphing
Creación de una definición de dispositivo personalizado
15
El diseño de una interfaz de usuario utilizando la herramienta Diseñador Android Estudio
Un Diseñador Android Estudio Herramienta Ejemplo
Creación de una nueva actividad
Edición de propiedades de la vista
Creación manual de un diseño XML
Uso del Visor Jerarquía
16
Creación de una interfaz de usuario de Android en el Código Java utilizando Android Estudio
Código Java vs. XML archivos de diseño
Creación de vistas
Propiedades y parámetros de diseño
Crear el proyecto de ejemplo en Android Estudio
Adición Vistas a una actividad
Configuración de propiedades de la vista
Agregar parámetros y reglas de diseño
Usando Ver IDs
Píxeles Independientes Densidad Conversión (dp) a píxeles (px)
17
Uso del Administrador de Android GridLayout en Android Studio Designer
La introducción de las Clases Android GridLayout y el Espacio
El GridLayout Ejemplo
Crear el proyecto GridLayout
Crear el GridLayout Instancia
Adición Vistas a células GridLayout
Mover y eliminar filas y columnas
La implementación de la fila de la célula y Spanning Columna
Cambio de la gravedad de un GridLayout Niño
18
Trabajar con el GridLayout Android usando Recursos Disposición XML
GridLayouts en archivos de recursos XML
Adición de Niños Vistas a la GridLayout
Declarando Spanning Cell, Gravedad y Márgenes
19
Una visión general y Android Estudio Ejemplo de Manejo Android Evento
Entender Eventos Android
Uso de Android: Recursos onClick
Detectores de eventos y métodos de devolución de llamada
Un ejemplo Manejo de Eventos
El detector de eventos y método de devolución de llamada
Utilizar eventos
20
Touch Android y multi-touch control de eventos en Android Estudio
Interceptar Eventos Touch
El Objeto MotionEvent
A.Táctiles Comprensión
Manejo de múltiples toques
Un Multi-Touch Ejemplo de Aplicación
El diseño de la interfaz de la actividad del usuario
Implementación del Evento Listener Touch
Ejecutar la aplicación Ejemplo
21
La detección de gestos comunes que utilizan Android Studio y el Gesto Detector Clase
La implementación de Detección Gesto Común
Creación de un proyecto de detección de gestos Ejemplo
La implementación de la clase Listener
Creación de la GestureDetectorCompat Instancia
La implementación de la onTouchEvent Método ()
22
La implementación de reconocimiento de gestos Android personalizada con Android Estudio
El embrujo de Android Application Builder
La Clase GestureOverlayView
La detección de gestos
La identificación de los gestos específicos
Añadir Soporte de tarjetas SD a un AVD
Creación y ejecución de la Application Builder Gesto
Creación de un archivo Gestos
Extraer el archivo Gestos de la tarjeta SD
Crear el proyecto de ejemplo
Adición de los Gestos archivo al proyecto
Carga del archivo Gestos
Registrando el detector de eventos
Implementación del Método onGesturePerformed
Configuración del GestureOverlayView
Interceptar Gestos
La detección de gestos de pellizco en Android
Un gesto de pellizcar Ejemplo de proyecto
23
Introducción al uso de fragmentos en Android Estudio
¿Qué es un fragmento?
Creación de un fragmento
Adición de un fragmento de una actividad utilizando el archivo XML Layout
Adición y Gestión de Fragmentos de Código
Gestión de eventos Fragmento
Ejecución Fragmento Comunicación
24
Usando fragmentos en Android Studio - Un Ejemplo
Sobre el Fragmento Ejemplo de Aplicación
Crear el primer fragmento Layout
Crear el primer fragmento Clase
La creación de la Segunda Fragmento Layout
Adición de los fragmentos de la Actividad
Hacer la barra de herramientas Fragmento Hable con la Actividad
Hacer la Actividad Hable con el fragmento de texto ]
25
Un Maestro Android estudio / Detalle Flujo Tutorial
El Android Maestro / Detalle de Flujo
Creación de un maestro / detalle de Flujo de Actividad
La anatomía del Maestro / Detalle Plantilla de Flujo
Modificación del Maestro / Detalle Plantilla de Flujo
Cambiar el modelo de contenido
Cambiar el panel de detalles
Modificación de la Clase WebsiteDetailFragment
Adición de permisos Manifest
26
Creación y administración de desbordamiento de los menús en Android Estudio
El menú de desbordamiento
Creación de un menú de desbordamiento
Viendo un menú de desbordamiento
Respondiendo a Menú Elemento Selecciones
Creación de grupos de artículos checkable
Modificación del menú Descripción
Modificación de la (Método onOptionsItemSelected)
27
Animación de interfaces de usuario en Android Studio usando el Marco Transiciones
La introducción de las transiciones y escenas Android
Usando Interpoladores con transiciones
Trabajo con transiciones de escena
Transiciones y TransitionSets en código personalizado
Transiciones y TransitionSets en XML personalizados
Trabajar con Interpoladores
Creación de un interpolador personalizada
Utilizar el método beginDelayedTransition
28
Un Android Estudio Transición Tutorial usando beginDelayedTransition
Crear el proyecto Android Estudio TransitionDemo
Preparación de los archivos de proyecto
Ejecución beginDelayedTransition Animación
Personalización de la Transición
29
Ejecución Escena Android Transiciones - Un Estudio Android Tutorial
Una visión general del Proyecto de Transición de Escena
Crear el proyecto SceneTransitions Android Estudio
La identificación y preparación del contenedor raíz
El diseño de la primera escena
El diseño de la segunda escena
Entrando en la primera escena
Cargando Escena 2
La aplicación de las transiciones
Agregar el archivo de Transición
Cargando y Manejo del Set Transición
Configuración de transiciones adicionales
30
Una visión general de Intenciones en Android Estudio
Una visión general de Intenciones
Intenciones explícitos
Devolver datos de una Actividad
Intenciones implícitos
El uso de Intención Filtros
Comprobación de Intención disponibilidad
31
Intenciones explícitos Android - Un Estudio Android Ejemplo
Creación de la explícita intención Ejemplo de Aplicación
Diseño de la disposición de la interfaz de usuario para ActivityA
Creación de la segunda clase de actividad
Diseño de la disposición de la interfaz de usuario para ActivityB
Revisando el archivo de manifiesto de aplicación
Creación de la Intención
La extracción de los datos de intención
Lanzamiento ActivityB como Sub-Actividad
Devolver datos de un Sub-Actividad
32
Intenciones implícitos Android - Un Estudio Android Ejemplo
Crear el Android Estudio implícito Intención Proyecto Ejemplo
Creación de la Intención Implícita
Adición de una segunda actividad Matching
Adición de la web Ver en la interfaz de usuario
La obtención de la URL Intención
Modificación del archivo MyWebView Proyecto Manifiesto
33
Broadcast Intenciones y receptores de radiodifusión en Android Estudio
Una visión general de Difusión Intenciones
Una visión general de los receptores de radiodifusión
La obtención de resultados a partir de un Broadcast
Sticky Broadcast Intenciones
El Ejemplo Broadcast Intención
Crear el ejemplo de aplicación
Creación y envío de la Intención Broadcast
Crear el Receptor Broadcast
Configuración de un receptor de radiodifusión en el archivo de manifiesto
Probando el Ejemplo Broadcast
Escuchando transmisiones del sistema
34
Hilos e hilo Android Manipuladores - Un Estudio Android Tutorial
Una visión general de los Hilos
El hilo principal de la aplicación
Los manejadores de hilos
Una rosca Ejemplo básico
Crear un nuevo hilo
La implementación de un manejador de Tema
Al pasar un mensaje a los Handler
35
Descripción de los servicios Android comenzado y Bound
Servicios empezados
Servicio de Intención
Servicio Bound
La Anatomía de un servicio
Controlar Opciones Reiniciar servicio Destroyed
Declarar un servicio en el archivo de manifiesto
Inicio de un servicio que se ejecuta en el inicio del sistema
36
La implementación de un servicio de Android Iniciado en Android Estudio
Creación de la clase de servicio
Añadiendo el Servicio para el archivo de manifiesto
Inicio del servicio
Probando el Ejemplo IntentService
Utilizando la clase de servicio
Cómo crear un nuevo servicio
La modificación de la interfaz de usuario
Crear un nuevo hilo para tareas de servicio
37
Implementar Servicios Bound locales en Android Estudio
Comprensión Bound Servicios
Bound Servicio Opciones de interacción
Un servicio Ejemplo Bound Android Estudio Local
Adición de un servicio Bound con el Proyecto
La implementación de la Carpeta
La unión del Cliente para el Servicio
Completando el Ejemplo
38
Android Servicios Bound remoto - Un Estudio Android Tutorial
Cliente Comunicación del servicio remoto
Implementación del Servicio Bound remoto
Configuración de un servicio remoto en el archivo de manifiesto
Lanzamiento y unión al servicio remoto
El envío de un mensaje al servicio remoto
39
Una visión general de las bases de datos SQLite Android en Android Estudio
La comprensión de las Tablas de base de datos
La introducción de esquemas de bases de datos
Las columnas y tipos de datos
Filas de bases de datos
La introducción de claves principales
¿Qué es SQLite?
Structured Query Language (SQL)
Tratando SQLite en un dispositivo virtual de Android (AVD)
Clases Android SQLite Java
Cursor
SQLiteDatabase
SQLiteOpenHelper
ContentValues
40
Un Android Estudio TableLayout y TableRow Tutorial
Los TableLayout y TableRow Disposición Vistas
Crear el proyecto de base de datos
Agregar el TableLayout a la interfaz de usuario
Agregar y configurar los filastabla
Adición de la barra de botones para el diseño
Ajuste de los márgenes de disposición
41
Un Tutorial de base de datos SQLite Android Estudio
Sobre la base de datos Ejemplo Android Estudio
Creación del modelo de datos
Implementar el manejador de datos
El método Add Handler
El método de control de la consulta
El método Delete Handler
La implementación de los métodos activos de eventos
42
La comprensión de Proveedores de Contenido Android en Android Estudio
¿Qué es un Proveedor de Contenido?
El proveedor de contenidos
onCreate ()
query ()
insert ()
update ()
delete ()
getType ()
El URI contenido
El contenido del resolver
El <proveedor> Element Manifiesto
43
Un proveedor de contenidos Android Estudio Ejemplo
Copia de la base de datos del proyecto
Agregar el Proveedor Contenido del paquete
Creación de la Clase Proveedor de Contenido
La construcción de la Autoridad y contenido URI
Implementar Matching URI en el Proveedor de Contenido
Implementación del Proveedor de Contenido onCreate () Método
La implementación de la inserción Proveedor de Contenido Método ()
La implementación de la consulta Proveedor de Contenido Método ()
La implementación de la actualización Proveedor de Contenido Método ()
Implementación del Proveedor de Contenido eliminar Método ()
Declarando el proveedor de contenidos en el archivo de manifiesto
Modificación de la base de datos Handler
44
Acceso Cloud Storage utilizando el Marco para un acceso de almacenamiento en Android Estudio
El Marco de Acceso de almacenamiento
Trabajando con el Marco de Acceso de almacenamiento
Listados selector de archivos de filtrado
Manejo de Resultados Intención
Leyendo el contenido de un archivo
Escritura de contenido a un archivo
Eliminación de un archivo
Obtener acceso permanente a un archivo
45
Un Android Estudio Acceso de almacenamiento Marco Ejemplo
Sobre el Ejemplo Acceso de almacenamiento Marco
Crear el Acceso de almacenamiento Marco Ejemplo
Declarando Solicitar Códigos
Crear un nuevo archivo de almacenamiento
El onActivityResult (Método)
Guardar en un archivo de almacenamiento
Abrir y leer un archivo de almacenamiento
Prueba de la aplicación de almacenamiento de acceso
46
Un Android Estudio VideoView y MediaController Tutorial
Al presentar el Android VideoView Clase
Al presentar el Android MediaController Clase
Prueba de reproducción de vídeo
Creación de la reproducción de vídeo Ejemplo
Diseñar el VideoPlayer Layout
Configuración del VideoView
Adición de permisos de Internet
Agregar el MediaController al vídeo Ver
Configuración de la onPreparedListener
47
Grabación de vídeo y captura de imagen usando Intenciones cámara - Un Estudio Android Ejemplo
Comprobación de la ayuda de la cámara
Llamar a la Intención de captura de vídeo
Llamar a la Intención de captura de imagen
Crear un proyecto Android Estudio de grabación de vídeo
El diseño de la interfaz de usuario de diseño
Comprobación de la Cámara
Lanzamiento de la Intención de captura de vídeo
Manejo del Retorno Intención
48
Una grabación y reproducción Ejemplo Android Studio usando MediaPlayer y MediaRecorder
Reproducción de audio
Grabación de audio y vídeo utilizando la clase MediaRecorder
Sobre el Proyecto Ejemplo
Crear el proyecto AudioApp
Comprobación de disponibilidad Micrófono
Realización de la Actividad de inicialización
La implementación de la (Método recordAudio)
La implementación de la stopAudio Método ()
Implementación del método playaudio ()
Configuración de permisos en el archivo de manifiesto
49
Trabajar con el API de Google Maps para Android en Android Estudio
Los Elementos de la API de Google Maps para Android
Prepárese para utilizar la API de Google Maps para Android
Instalación de las API de Google
Descarga de la Google Play Servicios SDK
Agregar el Google Play Servicios Biblioteca al Gradle Construir configuración
Para obtener su firma desarrollador
Registro del Proyecto en la consola de las API Google
Adición Mapa Apoyo al archivo AndroidManifest.xml
Comprobación de los servicios de Google Play Soporte
La comprensión de geocodificación y geocodificación inversa
Agregar un mapa a una aplicación
Viendo del usuario Ubicación actual
Cambiar el tipo de mapa
Viendo Mapa Controles al Usuario
Manipulación Mapa Gesto Interacción
Mapa Zooming Gestos
Mapa Desplazamiento / Desplazamiento Gestos
Mapa inclinación Gestos
Rotación del mapa Gestos
Creación de marcadores de mapa
Controlar el Mapa de la cámara
50
Impresión con el Marco Impresión Android en Android Estudio
La impresión Arquitectura Android
El Servicios de impresión HP Plugin
Google Cloud Print
Impresión a Google Drive
Guardar como PDF
Impresión desde dispositivos Android
Opciones para Construir Imprimir Apoyo en Aplicaciones Android
Impresión de imágenes
Creación y contenido impresión HTML
Impresión de una página Web
Impresión de un documento personalizado
51
Un HTML Android Studio y contenido Web Printing Ejemplo
Creación del HTML Impresión Ejemplo de Aplicación
Contenido impresión HTML dinámico
Creación de la página Web Impresión Ejemplo
El diseño de la interfaz de usuario de diseño
Adición de la opción de impresión del menú
52
Un documento Impresión Ejemplo Android Estudio personalizado
Una visión general de la Imprenta Android documento personalizado
Adaptadores encargo de impresión
Preparación del Proyecto Custom documento Impresión
Crear el adaptador de impresión personalizada
La implementación de la OnLayout () Método de devolución de llamada
La implementación de la OnWrite () Método de devolución de llamada
Comprobación de una página está en Gama
Dibujando el contenido de la página Lienzo
A partir del trabajo de impresión
53
Generación de un archivo de lanzamiento APK Firmado en Android Estudio
El proceso de preparación de estreno
Cambio de la Variante Build
Creación de un archivo de almacén de claves
Generación de una clave privada
Crear la aplicación APK Archivo
Regístrese para obtener una cuenta de Google Play Consola desarrollador
Cargar Versiones Nueva APK a la Consola de Google Play desarrollador
54
Un estudio Android Google Play In-App Tutorial facturación
Instalación de la biblioteca Google Play facturación
Crear el proyecto de facturación Ejemplo In-App
Adición de Permiso de facturación para el archivo de manifiesto
Agregar el archivo IInAppBillingService.aidl al Proyecto
Añadiendo las clases de utilidad para el Proyecto
La aplicación de la "Click Me" Botón
Google Consola Juega desarrollador y Cuentas de Google Wallet
La obtención de la clave de licencia pública para la Aplicación
Configuración de Google Play de facturación en la Solicitud
Inicio de una Factura de Compra Google Play In-App
Implementación del Método onActivityResult
La implementación del proceso de escucha Terminado Compra
Consumir el artículo comprado
Al soltar el IabHelper Instancia
Modificación del archivo Security.java
Prueba de la aplicación de facturación en app
La construcción de una APK lanzamiento
Creación de un nuevo In-App Producto
La publicación de la solicitud para el Canal de Distribución Alfa
Adición de cuentas de prueba de facturación en app
Configuración Testing Group
Resolución de problemas con In-App de Compras [
55
Una visión general de Gradle en Android Estudio
Una visión general de Gradle
Gradle y Android Estudio
Parámetros por defecto
Dependencias
Construir Las variantes
Entradas Manifest
APK Firma
Soporte ProGuard
El nivel superior Gradle Construir Archivo
Módulo Nivel Gradle Archivos de creación
Configuración de los valores de firma en el archivo de creación
Ejecución de tareas Gradle desde la línea de comandos
56
Un Android Estudio Gradle Construir Las variantes Ejemplo
Creación de la Variante Ejemplo Generar proyecto
Adición de los Sabores Construir al Build Module Archivo
Adición de los Sabores de la estructura del proyecto
Adición de archivos de recursos de los Sabores
Prueba de los Sabores Complexión
Construir variantes y Clases Archivos
Adición de paquetes a los Sabores Complexión
Personalización de las clases de actividad
1 La creación de un equipo con Windows, Linux o Mac OS
X Android Ambiente Development Studio
Antes de cualquier trabajo puede comenzar en el desarrollo de una aplicación para Android, el primer paso es
configurar un sistema informático para actuar como plataforma de desarrollo. Esto implica una serie de etapas
que consisten en la instalación del Java Development Kit (JDK) y el Android Estudio Entorno Integrado de
Desarrollo (IDE), que también incluye el Kit de desarrollo de software de Android (SDK).
Este capítulo cubre los pasos necesarios para instalar los componentes necesarios para el desarrollo de
aplicaciones para Android en sistemas basados en Windows, Mac OS X y Linux.
Requisitos del sistema

Desarrollo de aplicaciones Android se puede realizar en cualquiera de los siguientes tipos de sistemas:
 Windows XP (32-bit)
 Windows Vista (32-bit o 64-bit)
 Windows 7 (32 bits o 64 bits)
 Windows 8 / Windows 8.1
 (Sólo sistemas basados en Intel) Mac OS X 10.5.8 o posterior
 Sistemas Linux con la versión 2.7 o posterior de GNU C Library (glibc)
Instalación del Java Development Kit (JDK)

El SDK de Android fue desarrollado utilizando el lenguaje de programación Java. Del mismo modo, las
aplicaciones de Android también se desarrollan utilizando Java.Como resultado, el Java Development Kit (JDK)
es el primer componente que se debe instalar.
El desarrollo de Android requiere la instalación de la edición estándar de la versión Kit de Desarrollo Java
Platform 6 o posterior. Java es provista en desarrollo (JDK) y de tiempo de ejecución de paquetes (JRE). A los
efectos del desarrollo de Android, el JDK debe ser instalado.
Instalación de Windows JDK

Para los sistemas Windows, el JDK se puede obtener de la página web de Oracle Corporation mediante la
siguiente URL:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Suponiendo que un JDK adecuado no está instalado en su sistema, descargue el último paquete JDK que
coincida con el sistema de ordenador de destino. Una vez descargado, ejecute el archivo ejecutable de
instalación y siga las instrucciones en pantalla para completar el proceso de instalación.
Instalación de Mac OS X JDK
El entorno Java SE 6 o una versión más reciente ya deben estar instalados en las últimas versiones de Mac OS
X. Para confirmar la versión que está instalada, abra una ventana de terminal y escriba el siguiente comando:
java -version
Suponiendo que Java está instalado actualmente, una salida similar a la siguiente aparecerá en la ventana de
terminal:
java version "1.6.0_65"

Java (TM) SE Runtime Environment (build 1.6.0_65-b14-462-11M4609)
Java HotSpot (TM) 64-Bit Servidor VM (build 20.65-b04-462, modo mixto)
En el caso de que Java no está instalado, el comando "java" en la ventana de terminal dará lugar a la aparición
de un mensaje que dice lo siguiente junto con un cuadro de diálogo en el escritorio que proporciona la opción
para mostrar la página web de Oracle Java:
Sin tiempo de ejecución de Java actual, solicitando instalar
Los pasos exactos que deben tomarse para instalar Java varían de una versión de Mac OS X para el próximo fin
de comprobar la documentación de Apple para su particular versión de Mac OS X. En el momento de escribir la
última versión de Mac OS X es 10.9 (Mavericks). Para instalar Java en esta versión de Mac OS X, abra una
ventana del navegador Safari y vaya a la siguiente URL:
http://support.apple.com/kb/DL1572
Esto debería mostrar el Java para OS X 2013-005 página web. Haga clic en el botón Descargar para descargar
el paquete de Java en su sistema. Abre la imagen descargada de disco (archivo .dmg) y haga doble clic en el
archivo del paquete JavaForOSX.pkg (Figura 1-1) contenida dentro:
Java para OS X instalador ventana aparecerá y te llevará a través de los pasos necesarios para la instalación
del JDK. Una vez finalizada la instalación, vuelva a la ventana de terminal y ejecute el mandato siguiente,
momento en el que debe aparecer la información de la versión Java anteriormente descrito:
java -version
Instalación de Linux JDK

En primer lugar, si el sistema de desarrollo elegido está ejecutando la versión de 64 bits de Ubuntu, entonces es
esencial que se instale el paquete de soporte de biblioteca de 32 bits:
sudo apt-get install ia32-libs
Al igual que con la instalación de JDK basado en Windows, es posible instalar el JDK en Linux descargando el
paquete adecuado desde el sitio web de Oracle, la URL para el que es el
siguiente: http://www.oracle.com/technetwork/java/javase /downloads/index.html paquetes son proporcionados
por Oracle en formato RPM (para la instalación en sistemas basados en Red Hat Linux como Red Hat
Enterprise Linux, Fedora y CentOS) y como un archivo tar para otras distribuciones de Linux como Ubuntu.
En los sistemas Linux basados en Red Hat, descargue el archivo .rpm JDK desde el sitio web de Oracle y
realizar la instalación utilizando el comando rpm en una ventana de terminal. Suponiendo, por ejemplo, que el
archivo descargado JDK fue nombrado jdk-7u45-linux-x64.rpm, los comandos para realizar la instalación con el
siguiente texto:
Do
rpm -ihv jdk-7u45-linux-x64.rpm
Para instalar utilizando el paquete tar comprimido (tar.gz) realice los siguientes pasos:
1. Cree el directorio en el que el JDK se va a instalar (para los fines de este ejemplo supondremos / home /
demo / java). 2. Descargue el paquete tar.gz apropiada desde el sitio web de Oracle en el directorio. 3. Ejecute
el comando siguiente (donde <jdk-file> se reemplaza por el nombre del archivo descargado JDK):
tar xvfz <jdk-file> .tar.gz
4. Retire el archivo tar.gz descargado. 5. Añada la ruta al directorio bin de la instalación JDK a la variable $
PATH. Por ejemplo, suponiendo que el JDK instalado finalmente en /home/demo/java/jdk1.7.0_45 necesitaría lo
siguiente para ser añadido a la variable de entorno $ RUTA:
/home/demo/java/jdk1.7.0_45/bin
Normalmente, esto se puede lograr mediante la adición de un comando al archivo .bashrc en su directorio
principal (detalles pueden variar en función de la distribución de Linux en particular en uso). Por ejemplo, cambie
el directorio a su directorio, edite el archivo .bashrc contenida en el mismo y añadir la siguiente línea al final del
archivo (modificando el camino para que coincida con la ubicación del JDK en su sistema):
export PATH = / home / demo / java / jdk1.7.0_45 / bin: $ PATH
Después de haber guardado el cambio, las futuras sesiones de terminal incluirán el JDK en la variable de
entorno $ PATH.
La descarga del paquete Android Estudio

La mayor parte del trabajo involucrado en el desarrollo de aplicaciones para Android se realizarán utilizando el
entorno Android Studio. Android estudio se puede descargar de la siguiente página web:
http://developer.android.com/sdk/installing/studio.html
Desde esta página, o bien haga clic en el botón de descarga si las listas de la plataforma correcta (por ejemplo
en un navegador web basado en Windows en el botón leerá "Download Android Studio for Windows"), o
seleccione la opción "Descargar para otras plataformas" de forma manual seleccione el paquete adecuado para
su plataforma y sistema operativo. En la siguiente pantalla, acepte los términos y condiciones para iniciar la
descarga.
La instalación en Windows
Busque el archivo descargado Android Estudio ejecutable de instalación (llamado androide-studio-Bundle-
<versión> .exe) en una ventana del Explorador de Windows y haga doble clic sobre él para iniciar el proceso de
instalación, haga clic en el botón Sí en el cuadro de diálogo Control de cuentas de usuario si aparece.
Una vez que aparezca el asistente de configuración de Android de estudio, trabajo a través de las diferentes
pantallas para configurar la instalación para satisfacer sus necesidades en cuanto a la ubicación del sistema de
archivos en el que Android estudio debe ser instalado y si es o no debería ponerse a disposición de otros
usuarios del sistema . Aunque no hay reglas estrictas sobre dónde se debe instalar Android Studio en el
sistema, el resto de este libro se asume que la instalación se realizó en una subcarpeta del directorio principal
llamado android-estudio del usuario. Una vez que las opciones se han configurado, haga clic en el botón Instalar
para comenzar el proceso de instalación.
En las versiones de Windows con un menú de inicio, el recién instalado Android Studio puede ser lanzado desde
la entrada secundaria a ese menú durante la instalación.En Windows 8, el ejecutable se puede fijar a la barra de
tareas para facilitar el acceso, vaya hasta el directorio \ bin android-estudio, haciendo clic derecho sobre el
ejecutable y seleccionando la opción de menú Pin a la barra de tareas. Tenga en cuenta que el ejecutable se
proporciona en 32-bit (estudio) y 64 bits (studio64) versiones ejecutables. Si está ejecutando un sistema de 32
bits, asegúrese de usar el ejecutable estudio.
Instalación en Mac OS X
Android Studio for Mac OS X se descarga en forma de un archivo de imagen de disco (.dmg). Una vez que el-
studio-Bundle- androide <version> -mac.dmg se ha descargado, ubicarlo en una ventana del Finder y haga
doble clic en él para abrirlo como se muestra en la Figura 2-2:
Figura 2-2
Para instalar el paquete, basta con arrastrar el icono de Android Studio y suéltala en el ícono Aplicaciones. El
paquete de Android estudio se instalará en la carpeta Aplicaciones del sistema, un proceso que normalmente se
tome unos minutos para completar.
Para lanzar Android de estudio, localizar el ejecutable en la carpeta Aplicaciones utilizando una ventana del
Finder y haga doble clic en él.
Para el futuro más fácil acceso a la herramienta, arrastre el icono de Android Estudio de la ventana del Finder y
suéltala en el muelle.
Instalación en Linux
Después de haber descargado el paquete de Linux Android Studio, abra una ventana de terminal, cambie el
directorio a la ubicación en Android estudio se va a instalar y ejecutar el siguiente comando:
tar xvf / <ruta de acceso al paquete> / android-studio-Bundle- <versión> .tgz
Tenga en cuenta que el paquete Android estudio se instalará en un androide-estudio sub-directorio

llamado. Suponiendo, pues, que el comando anterior fue ejecutado en / home / demo, los paquetes de software
se descomprime en / home / demo / android-estudio.
Para lanzar Android Studio, abra una ventana de terminal, cambie el directorio a la / subdirectorio bin android-
studio y ejecutar el siguiente comando:
./studio.sh
Instalación de los últimos paquetes SDK de Android

Los pasos realizados hasta ahora han instalado Java, Android Studio IDE y el conjunto actual de paquetes SDK
defecto de Android. Antes de continuar, vale la pena tomar algún tiempo para verificar que están instalados los
paquetes e instalar los paquetes que falten.
Esta tarea se puede realizar mediante el Gestor de SDK de Android, que puede ser lanzado desde dentro de la
herramienta Android Estudio seleccionando Configurar el -> opción SDK Manager desde dentro del diálogo de
bienvenida Android Studio. Una vez invocado, la herramienta Manager SDK aparecerá como se ilustra en la
Figura 2-3:
Comience comprobando que el Camino SDK: ajuste en la parte superior de la ventana de Manager SDK
coincide con la ubicación en la que se instaló el Estudio Android.Dentro del Administrador de Android SDK,
asegúrese de que las casillas de verificación junto a los siguientes paquetes aparecen como Instalada en la
columna Estado:
 Herramientas> Herramientas del SDK de Android

 Herramientas> Android SDK Platform-herramientas
 Platform SDK (versión más reciente)> Platform SDK
 Platform SDK (versión más reciente)> ARM EABI Sistema v7a Imagen
Tenga en cuenta que la Plataforma SDK ya está disponible en estándar, L y W variantes. Para los propósitos de
este libro no es necesario descargar la L y W versiones de los paquetes de la plataforma SDK.
 Extras -> Android Ayuda Repositorio

 Extras> Android Soporte Biblioteca
 Extras -> Google Repositorio
 Extras -> Conductor Google USB
En el caso de que alguno de los paquetes anteriores se muestran como No instalado, sólo tiene que seleccionar
las casillas de verificación junto a los paquetes y haga clic en el botón Instalar paquetes para iniciar el proceso
de instalación. En el cuadro de diálogo resultante, acepte los acuerdos de licencia antes de hacer clic en el
botón Instalar. El SDK Manager entonces comenzará a descargar e instalar los paquetes designados. A medida
que avanza la instalación, aparecerá una barra de progreso en la parte inferior de la ventana del administrador
que indica el estado de la instalación.
Una vez completada la instalación, revise la lista de paquetes y asegurarse de que los paquetes seleccionados
aparecen ahora como Instalada en la columna Estado. Si alguno aparece como No instalado, asegúrese de que
estén seleccionados y haga clic en Instalar paquetes ... botón de nuevo.
Hacer las herramientas del SDK de línea de comandos Android Accesible

La mayoría de las veces, se accederá a las herramientas fundamentales de la SDK de Android desde el entorno
de Android Studio. Dicho esto, sin embargo, también habrá casos en los que será útil para poder invocar esas
herramientas desde la línea de comandos o ventana terminal. Para que el sistema operativo en el que se están
desarrollando para poder encontrar estas herramientas, será necesario añadir a la variable de entorno PATH del
sistema.
Independientemente del sistema operativo, la variable PATH debe configurarse para incluir las siguientes rutas
(donde <path_to_android_studio_installation> la ubicación del sistema de archivos en el que se instaló el
paquete ADT):
<path_to_android_studio_installation> / sdk / herramientas

<path_to_android_studio_installation> / sdk / plataforma de herramientas
Los pasos para lograr este sistema están operando dependiente:
Windows 7
1. Haga clic derecho en el equipo en el menú Inicio del escritorio y seleccione Propiedades en el menú
resultante. 2. En el panel de propiedades, seleccione el enlace Configuración avanzada del sistema y, en el
cuadro de diálogo resultante, haga clic en las variables de entorno ... botón. 3. En el cuadro de diálogo Variables
de entorno, localice la variable Path en la lista de variables del sistema, selecciónela y haga clic en
Editar .... Busque el final de la cadena de valor variable actual y añadir la ruta de acceso a las herramientas de
la plataforma Android para el final, con un punto y coma para separar el camino de los valores anteriores. Por
ejemplo, suponiendo Android Estudio se instala en / Users / demo / android-estudio, se añade al final del valor
actual Sendero lo siguiente:
; C: \ Users \ demo \ android-studio \ sdk \ Platform-tools; C: \ Users \ demo \

android-studio \ sdk \ tools
4. Haga clic en Aceptar en cada cuadro de diálogo y cierre el panel de propiedades del sistema de control. Una
vez que los pasos anteriores se han completado, verifique que la ruta esté ajustada correctamente abriendo una
ventana de símbolo del sistema (Inicio -> Todos los programas -> Accesorios -> Símbolo del sistema) y en el
indicador de entrar:
echo% PATH%
El valor de la variable ruta devuelta debe incluir las rutas de acceso a las herramientas de la plataforma SDK
Android carpetas. Compruebe que el valor de la plataforma-tools es correcta al intentar ejecutar la herramienta
adb de la siguiente manera:
adb
La herramienta debe ser la salida una lista de opciones de la línea de comandos cuando se ejecuta.
Del mismo modo, comprobar que la ruta herramientas ajuste al intentar iniciar el Administrador de Android SDK:
androide
En el caso de que aparezca un mensaje similar al siguiente mensaje para uno o ambos de los comandos, lo
más probable es que una ruta incorrecta se adjuntó a la variable de entorno Path:
"Adb" no se reconoce como un comando interno o externo,

programa o archivo por lotes.
De Windows 8.1
1. En la pantalla de inicio, mueva el ratón a la esquina inferior derecha de la pantalla y seleccione Buscar en el
menú resultante. En el cuadro de búsqueda, escriba Panel de control. Cuando el icono Panel de control aparece
en el área de resultados, haga clic en él para iniciar la herramienta en el escritorio. 2. En el panel de control,
utilice el menú Categoría para cambiar la pantalla a Iconos grandes. En la lista de iconos de seleccionar la de la
etiqueta del sistema. 3. Siga los pasos indicados para Windows 7 desde el paso 2 al paso 4.
Abra la ventana de símbolo del sistema (mover el ratón a la esquina inferior derecha de la pantalla, seleccione la
opción Buscar y escriba cmd en el cuadro de búsqueda).Seleccione Símbolo del sistema a partir de los
resultados de búsqueda. Dentro de la ventana del símbolo del sistema, escriba:
echo% PATH%
El valor de la variable ruta devuelta debe incluir las rutas de acceso a las herramientas de la plataforma SDK
Android carpetas. Compruebe que el valor de la plataforma-tools es correcta al intentar ejecutar la herramienta
adb de la siguiente manera:
adb
La herramienta debe ser la salida una lista de opciones de la línea de comandos cuando se ejecuta.
Del mismo modo, comprobar el ajuste de herramientas camino al tratar de lanzar el Manager SDK Android:
Android
En el caso de que aparezca un mensaje similar al siguiente mensaje para uno o ambos de los comandos, lo
más probable es que una ruta incorrecta se adjuntó a la variable de entorno Path:
"Adb" no se reconoce como un comando interno o externo,

programa o archivo por lotes.
Linux
En Linux esto implicará una vez más la edición del archivo .bashrc. Suponiendo que el paquete de paquete
Android Studio fue instalado en / home / demo / android-estudio, la línea de exportación en el archivo .bashrc
ahora diría lo siguiente:
exportación PATH=/home/demo/java/jdk1.7.0_10/bin:/home/demo/android-
studio/sdk/platform-tools:/home/demo/android-studio/sdk/tools:/home/demo/android-
studio/bin:$PATH
Tenga en cuenta también que el comando anterior se suma el directorio android-studio / bin a la variable
PATH. Esto permitirá a la secuencia de comandos studio.sh para ser ejecutado independientemente del
directorio actual dentro de una ventana de terminal.
Mac OS X
Un número de técnicas se puede emplear para modificar la variable de entorno $ PATH en Mac OS X. Podría
decirse que el método más limpio es agregar un nuevo archivo en el directorio /etc/paths.d que contiene las
rutas que se añade a $ PATH. Suponiendo una ubicación de instalación de / Aplicaciones / Android Studio.app,
la ruta puede ser configurado mediante la creación de un android-sdk nuevo archivo con el nombre en el
directorio /etc/paths.d contenga las siguientes líneas:
/ Aplicaciones / Android Studio.app / SDK / herramientas

/ Aplicaciones / Android Studio.app / SDK / plataforma de herramientas
Tenga en cuenta que, dado que se trata de un directorio del sistema, será necesario utilizar el comando sudo al
crear el archivo. Por ejemplo:
sudo vi /etc/paths.d/android-sdk
Actualización del Estudio de Android y el SDK
De vez en cuando las nuevas versiones de Android Studio y el SDK de Android se liberan. Las nuevas versiones
del SDK se instalan mediante el Administrador de Android SDK. Android Estudio normalmente le avise cuando
una actualización está listo para ser instalado.
Para comprobar manualmente si hay actualizaciones de Android Studio, haga clic en la opción Buscar
actualizaciones ahora conexión situado en la parte inferior de la pantalla de bienvenida Android de estudio, o
utilizar la Ayuda -> Buscar actualizaciones ... opción de menú accesible desde dentro de la ventana principal de
Android Studio.
Resumen
Antes de comenzar el desarrollo de aplicaciones basadas en Android, el primer paso es la creación de un
entorno de desarrollo adecuado. Esta consiste en el Java Development Kit (JDK), SDK de Android y Android
Studio IDE. En este capítulo, hemos cubierto los pasos necesarios para instalar estos paquetes en Windows,
Mac OS X y Linux.
2 Creación de una aplicación Android en Android Ejemplo

Estudio
En los capítulos anteriores de este libro han cubierto los pasos necesarios para configurar un entorno adecuado
para el desarrollo de aplicaciones de Android utilizando el IDE Android Studio. Antes de pasar a los temas un
poco más avanzados, ahora es un buen momento para validar que todos los paquetes de desarrollo necesarios
estén instalados y funcionando correctamente. La mejor manera de lograr este objetivo es la creación de una
aplicación para Android y compilarlo y ejecutarlo. Este capítulo tratará la creación de un proyecto de aplicación
Android sencilla utilizando Android Studio. Una vez que el proyecto ha sido creado, un capítulo posterior
explorará el uso del medio ambiente emulador de Android para realizar una prueba de funcionamiento de la
aplicación.
Creación de un nuevo proyecto de Android

El primer paso en el proceso de desarrollo de aplicaciones es la de crear un nuevo proyecto en el entorno
Android Studio. Comienza, por lo tanto, con el lanzamiento de Android Estudio para que aparezca la pantalla de
"Bienvenido a Android Studio" como se ilustra en la Figura 3-1:
Figura 3-1
Una vez que aparece esta ventana, Android estudio está listo para un nuevo proyecto que se
creará. Para crear el nuevo proyecto, simplemente haga clic en el nuevo proyecto ... opción para mostrar la
primera pantalla del asistente Nuevo proyecto tal como se muestra en la Figura 3-2:
Figura 3-2
Definición de la configuración del proyecto y SDK

En la ventana Nuevo proyecto, establezca el campo Nombre de la aplicación a AndroidSample. El nombre de la
aplicación es el nombre con el que se hará referencia a la solicitud e identificado en Android Studio y es también
el nombre que se utilizará cuando la solicitud completa sale a la venta en la tienda de Google Play.
El nombre del paquete se utiliza para identificar de forma única la solicitud dentro del ecosistema de
aplicaciones Android. Se debe basarse en la URL invertida de su nombre de dominio seguido por el nombre de
la aplicación. Por ejemplo, si su dominio es www.mycompany.com, y la aplicación ha sido nombrado
AndroidSample, a continuación, el nombre del paquete se puede especificar como sigue:
com.mycompany.androidsample
Si usted no tiene un nombre de dominio, también puede utilizar ebookfrenzy.com a los efectos de la prueba,
aunque esto tendrá que ser cambiado para que una aplicación pueda ser publicado:
com.ebookfrenzy.androidsample
El ajuste de la ubicación del proyecto será por defecto una ubicación en la carpeta denominada
AndroidStudioProjects situados en su directorio personal y puede ser cambiado haciendo clic en el botón situado
a la derecha del campo de texto que contiene la configuración de la ruta actual.
Haga clic en Siguiente para continuar. En la pantalla de factores de forma, activar la opción de teléfono y la
tableta y activar el ajuste de API 8 SDK mínimo: Android 2.2 (Froyo). Dado que el proyecto no está diseñado
para Google TV, Google Glass o dispositivos portátiles, dejar el resto de opciones desactivadas antes de hacer
clic en Siguiente.
En la última pantalla, introduzca AndroidSampleActivity para los campos, tanto el nombre de la actividad y título
y el nombre del activity_android_sample diseño.
Creación de una actividad
El siguiente paso es definir el tipo de actividad inicial que se va a crear para la aplicación. Una gama de
diferentes tipos de actividades está disponible en el desarrollo de aplicaciones de Android. La opción Master
Flow / detalle será cubierto en un capítulo posterior. A los efectos de este ejemplo, sin embargo, sólo tiene que
seleccionar la opción de crear una actividad en blanco antes de hacer clic en Siguiente.
Figura 3-3
Con la opción de Actividad en blanco seleccionado, haga clic en Siguiente. En la última pantalla
(Figura 3-4) nombrar la actividad y el título AndroidSampleActivity. La actividad consistirá en una presentación
de pantalla de interfaz de usuario única, que, a los efectos de este ejemplo, debería ser nombrado
activity_android_sample como se muestra en la Figura 3-4:
Figura 3-4
Por último, haga clic en Finalizar para iniciar el proceso de creación del proyecto.
Modificación del ejemplo de aplicación

En este punto, Android Studio ha creado un proyecto mínimo ejemplo de aplicación y abierto el proyecto
principal.
El proyecto y las referencias a los archivos asociados de nueva creación se enumeran en el panel de vista sobre
el proyecto a la izquierda de la ventana principal del proyecto. Esto refleja esencialmente la jerarquía de
directorios y archivos que se encuentran en la carpeta del proyecto en el sistema de archivos local del equipo de
desarrollo.
Figura 3-5
El proyecto de ejemplo creado para nosotros cuando seleccionamos la opción de crear una actividad consiste
en una interfaz de usuario que contiene un letrero que dijera: "Hola a todos" cuando se ejecuta la aplicación.
El siguiente paso en este tutorial es para modificar la interfaz de usuario de nuestra aplicación para que muestre
una vista de texto objeto más grande con un mensaje diferente al previsto para nosotros por Android Studio. El
diseño de la interfaz de usuario para nuestra actividad se almacena en un archivo llamado
activity_android_sample.xml que, a su vez, se encuentra bajo AndroidSample -> aplicación -> src -> res ->
diseño de la jerarquía de archivo del proyecto. Uso del panel Proyecto, localizar este archivo como se ilustra en
la Figura 3-6:
Figura 3-6
Una vez localizado, haga doble clic en el archivo para cargarlo en la herramienta Diseñador de interfaz de
usuario que aparecerá en el panel central de la ventana principal de Android Productora:
Figura 3-7
En la barra de herramientas en la parte superior del panel de editor de diseño es un menú que está configurada
actualmente para Nexus 4 que se refleja en la representación visual del dispositivo en el panel de Designer. Una
amplia gama de otras opciones del dispositivo están disponibles para su selección haciendo clic en este menú.
Para cambiar la orientación de la representación dispositivo entre el paisaje y retrato con sólo usar el menú
desplegable situado a la derecha del menú de selección de dispositivo muestra el icono.
Como puede verse en la pantalla del dispositivo, el diseño ya incluye una etiqueta que muestra un Hello
World! mensaje. Corriendo por el lado izquierdo del panel es una paleta que contiene diferentes categorías de
componentes de interfaz de usuario que pueden utilizarse para construir una interfaz de usuario, tales como
botones, etiquetas y campos de texto. Cabe señalar, sin embargo, que no todos los componentes de interfaz de
usuario son obviamente visibles para el usuario. Una de estas categorías se compone de diseños. Android es
compatible con una variedad de diseños diferentes que proporcionan diferentes niveles de control sobre la forma
visual de usuario componentes de interfaz están posicionados y gestionado en la pantalla. Aunque es difícil
decir de mirar a la representación visual de la interfaz de usuario, el diseño actual se ha creado utilizando un
RelativeLayout. Esto se puede confirmar mediante la revisión de la información en el panel Árbol de
componentes que, por defecto, se encuentra en la esquina superior derecha del panel Diseñador y se muestra
en la Figura 3-8:
Figura 3-8
Como podemos ver en la jerarquía de árbol de componentes, la interfaz de usuario se compone de un padre
RelativeLayout con un solo niño en la forma de un objeto TextView.
El primer paso en la modificación de la aplicación es para eliminar el componente TextView desde el
diseño. Comience haciendo clic sobre el objeto TextView dentro de la vista de la interfaz de usuario para que
aparezca con un borde azul alrededor. Una vez seleccionado, pulse la tecla Supr en el teclado para eliminar el
objeto de la disposición.
En el panel Paleta, localizar la categoría Widgets. Haga clic y arrastre el objeto de texto grande y colóquelo en el
centro del diseño de la interfaz de usuario cuando las líneas de marcador verde parecen indicar el centro de la
pantalla:
Figura 3-9
La herramienta Android Designer Studio también proporciona una alternativa a arrastrar y soltar los
componentes de la paleta a la disposición de diseño. Los componentes también pueden añadirse al seleccionar
el objeto deseado de la paleta y luego simplemente hacer clic en el diseño en el lugar en el que el componente
se va a colocar.
El siguiente paso es cambiar el texto que se muestra actualmente por el componente TextView. Haga
doble clic en el objeto en la disposición de diseño para mostrar el panel de edición de texto y la identificación
como se ilustra en la Figura 3-10. Dentro del panel, cambie la propiedad de texto "Texto grande" a "Bienvenido a
Android Studio".
Figura 3-10
En este punto es importante para explicar la bombilla al lado del objeto TextView en el diseño. Esto indica un
posible problema y ofrece algunas soluciones recomendadas. Al hacer clic en el icono en este caso nos informa
de que el problema es el siguiente:
[I18N] cadena codificada "Bienvenido a Android Studio", debe utilizar los

recursosstring
Este mensaje I18N nos está informando que existe un problema potencial con respecto a la futura
internacionalización del proyecto ("I18N" viene del hecho de que la palabra "internacionalización" comienza con
un "yo", termina con una "N" y tiene 18 letras entre ellas). La advertencia nos recuerda que en el desarrollo de
aplicaciones para Android, los atributos y valores como cadenas de texto deben ser almacenados en forma de
recursos siempre que sea posible. Si lo hace, permite cambios en la apariencia de la aplicación que se harán
mediante la modificación de los archivos de recursos en lugar de cambiar el código fuente de la aplicación. Esto
puede ser especialmente valioso cuando la traducción de una interfaz de usuario para una lengua hablada
diferente. Si todo el texto en una interfaz de usuario está contenida en un archivo de recursos único, por
ejemplo, ese archivo se puede dar a un traductor que a continuación, realizar el trabajo de traducción y devolver
el archivo traducido para su inclusión en la aplicación. Esto permite a varios idiomas para ser dirigidos sin la
necesidad de ningún cambio de código fuente a realizar. En este ejemplo, vamos a crear un nuevo recurso
denominado welcomestring y asignarle la cadena "Bienvenido a Android Studio".
Haga clic en la flecha a la derecha del mensaje de advertencia para mostrar el menú de posibles soluciones
(Figura 3-11).
Figura 3-11
En el menú, seleccione la opción de recurso de cadena Extraer para mostrar el diálogo Extract Resource. En
este cuadro de diálogo, introduzca welcomestring en el nombre del recurso: campo antes de hacer clic en
Aceptar. La cadena se almacena ahora como un recurso en el src -> res -> Valores -> archivo strings.xml.
La revisión de los archivos de diseño y Recursos
Antes de pasar al siguiente capítulo, vamos a mirar algunos de los aspectos internos de diseño de la interfaz de
usuario y el manejo de recursos. En la sección anterior, hemos hecho algunos cambios en la interfaz de usuario
mediante la modificación del archivo activity_android_sample.xml utilizando la herramienta Diseñador de interfaz
de usuario. De hecho, todo lo que el diseñador estaba haciendo era proporcionar una manera fácil de usar para
editar el contenido XML subyacente del archivo. En la práctica, no hay ninguna razón por la que no se puede
modificar el código XML directamente con el fin de hacer cambios en la interfaz de usuario y, en algunos casos,
en realidad esto puede ser más rápido que con la función Designer. En la parte inferior del panel Designer son
dos lengüetas de Diseño y de texto etiquetado respectivamente. Para cambiar a la vista XML sólo tiene que
seleccionar la ficha Texto como se muestra en la Figura 3-12:
Figura 3-12
Como puede verse a partir de la estructura del archivo XML, la interfaz de usuario consiste en el componente
RelativeLayout, que a su vez, es el padre del objeto TextView. También podemos ver que la propiedad text de la
TextView se establece en nuestro recurso welcomestring. Aunque varían en complejidad y contenido, todos los
diseños de interfaz de usuario se estructuran de esta manera jerárquica, basada en XML.
Una de las características más potentes de Android estudio se puede encontrar a la derecha del panel de
edición de XML. Este es el panel de vista previa y muestra el estado visual actual de la disposición. A medida
que se realizan cambios en el diseño de XML, estos se verán reflejados en el panel de vista previa. Para ver
esto en acción, modificar el diseño XML para cambiar el color de fondo de la RelativeLayout a un tono de rojo
como sigue:
<RelativeLayout xmlns: android = "http://schemas.android.com/apk/res/android"

xmlns: Herramientas = "http://schemas.android.com/tools"
android: layout_width = "match_parent"
android: layout_height = "match_parent"
android: paddingLeft = "@ dimen / activity_horizontal_margin"
android: paddingRight = "@ dimen / activity_horizontal_margin"
android: paddingTop = "@ dimen / activity_vertical_margin"
android: paddingBottom = "@ dimen / activity_vertical_margin"
herramientas: context = ". AndroidSampleActivity"
android: fondo = "# ff2438">
<TextView
android: layout_width = "wrap_content"
android: layout_height = "wrap_content"
android: textAppearance = "android:? attr / textAppearanceLarge"
android: text = "@ string / welcomestring"
android: id = "@ + / Identificación del TextView"
android: layout_centerVertical = "true"
android: layout_centerHorizontal = "true" />
</ RelativeLayout>
Tenga en cuenta que el color de los cambios de vista previa en tiempo real, para que coincida con la nueva
configuración en el archivo XML. Tenga en cuenta también que un pequeño cuadrado rojo aparece en el margen
izquierdo (también conocida como la cuneta) del editor de XML al lado de la línea que contiene la configuración
de color.Esta es una señal visual al hecho de que el color rojo se ha fijado en una propiedad. Cambie el valor de
color a # a0ff28 y tenga en cuenta que tanto la pequeña plaza en el margen y el cambio de vista previa para
verde.
Por último, utilice la vista de proyecto para localizar la aplicación -> src -> res -> Valores -> archivo strings.xml y
haga doble clic en él para cargarlo en el editor.Actualmente el XML debe decir lo siguiente:
<? Xml version = "1.0" encoding = "UTF-8"?>

<recursos>
<String name = "nombre_apl"> AndroidSample </ string>

<String name = "hello_world"> ¡Hola, mundo! </ String>
<String name = "action_settings"> Configuración </ string>
<String name = "welcomestring"> Bienvenido a Android Estudio </ string>
</ Recursos>
Como una demostración de los recursos en la acción, cambia el valor de la cadena actualmente asignado al
recurso welcomestring y luego volver al Diseñador seleccionando la pestaña del archivo de diseño en el panel
del editor. Tenga en cuenta que el diseño se ha recuperado el valor nuevo recurso para la cadena de
bienvenida.
También hay una forma rápida de acceder al valor de un recurso de referencia en un archivo XML. Con la
herramienta de diseño en modo de texto, haga clic en el "@ string / welcomestring" valor de la propiedad para
que se resalte y presione Ctrl + B en el teclado. Android Studio posteriormente abrir el archivo strings.xml y le
llevará a la línea de ese archivo en el que se declaró este recurso. Aproveche esta oportunidad para revertir el
recurso de cadena de nuevo a la "Bienvenido a Android Estudio" original del texto.
Vista previa de la Disposición

Hasta ahora, en este capítulo, la disposición sólo se ha visto previamente en una representación del dispositivo
Nexus 4. Como se mencionó anteriormente, el diseño puede ser probada por otros dispositivos mediante
selecciones en el menú del dispositivo en la barra de herramientas en el borde superior del panel Designer. Otra
opción útil proporcionada por este menú es la Vista previa Todos los tamaños de pantalla que, cuando se
selecciona, muestra el diseño en todas las configuraciones de los dispositivos configurados actualmente como
se demuestra en la Figura 3-13:
Figura 3-13
Para volver a un solo diseño vista previa, seleccione el menú del dispositivo, una vez más, esta vez de elegir la
opción Eliminar previstas.
Resumen
Aunque no es excesivamente complejo, una serie de pasos están involucrados en la creación de un entorno de
desarrollo de Android. Después de haber realizado estos pasos, vale la pena trabajar a través de un ejemplo
sencillo para asegurarse de que el medio ambiente se ha instalado y configurado correctamente. En este
capítulo, hemos creado una aplicación sencilla y luego se usa Diseñador Android interfaz de Studio para
modificar el diseño de la interfaz de usuario. Al hacerlo, hemos explorado la importancia de utilizar los recursos
siempre que sea posible, sobre todo en el caso de los valores de cadena, y brevemente tocó el tema de los
diseños. Por último, nos fijamos en el código XML subyacente que se utiliza para almacenar los diseños de
interfaz de usuario de las aplicaciones de Android.
Si bien es útil para poder previsualizar el diseño desde dentro de la herramienta Android Studio Designer, no
hay sustituto para probar una aplicación mediante la compilación y ejecutarlo. En un capítulo posterior
titulado Creación de un dispositivo virtual de Android (AVD) en Android estudio , los pasos necesarios para
configurar un emulador para propósitos de prueba se tratarán en detalle. Antes de ejecutar la aplicación, sin
embargo, el siguiente capítulo se llevará un pequeño desvío para ofrecer una visita guiada de la interfaz de
usuario de Android Studio.
3 Un recorrido por la interfaz de usuario de Android Estudio
Si bien es tentador para sumergirse en ejecutar la aplicación de ejemplo creado en el capítulo anterior, el
hacerlo implica el uso de los aspectos de la interfaz de usuario de Android estudio que se describe mejor por
adelantado. Android Studio es un entorno de desarrollo potente y rica característica que es, en gran medida, de
uso intuitivo.Dicho esto, tomando el tiempo para familiarizarse con el diseño y la organización de la interfaz de
usuario de Android Estudio acortará considerablemente la curva de aprendizaje en los últimos capítulos del
libro. Con esto en mente, este capítulo ofrecerá una visión general inicial de las distintas zonas y componentes
que conforman el entorno Android Studio.
La pantalla de bienvenida
La pantalla de bienvenida (Figura 4-1) se presenta cada vez que Android se ejecuta Studio con ningún proyecto
actualmente abiertos (proyectos abierto se puede cerrar en cualquier momento seleccionando Archivo -> opción
de menú Cerrar proyecto). Si Android Studio fue salió previamente mientras que un proyecto aún estaba abierta,
la herramienta-pasar por la pantalla de bienvenida próxima vez que se puso en marcha, abriendo
automáticamente el proyecto previamente activo.
Figura 4-1
Además de una lista de proyectos recientes, el menú Inicio rápido ofrece una gama de opciones para realizar
tareas como abrir, crear e importar proyectos junto con el acceso a los proyectos actualmente bajo control de
versiones. Además, la opción Configurar permite acceder al SDK Manager junto con una amplia gama de
configuraciones y opciones de configuración. Una revisión de estas opciones revelará rápidamente que no hay
casi ningún aspecto de Android Studio que no puede ser configurado y adaptado a sus necesidades específicas.
Por último, la barra de estado a lo largo del borde inferior de la ventana proporciona información sobre la versión
de Android Estudio actualmente en ejecución, junto con un enlace para comprobar si hay actualizaciones
disponibles para su descarga.
La ventana principal
Cuando se crea un nuevo proyecto, o una ya existente abre, aparecerá la ventana principal de Android
Studio. Cuando varios proyectos están abiertos a la vez, cada uno se le asignará su propia ventana principal. La
configuración precisa de la ventana puede variar dependiendo de la que se muestran las herramientas y los
paneles de la última vez que el proyecto estaba abierta, pero será típicamente parecerse a la de la Figura 4-2.
Figura 4-2
Los diversos elementos de la ventana principal se pueden resumir como sigue:

A - Barra de Menú - contiene una serie de menús para realizar tareas en el entorno Android Studio.
 B - Barra de herramientas - Una selección de los accesos directos a cabo con frecuencia
acciones. Los botones de la barra de herramientas proporcionan un acceso más rápido a un grupo selecto
de las acciones de la barra de menús. La barra de herramientas se puede personalizar haciendo clic
derecho sobre la barra y seleccionar Personalizar menús y barras de herramientas ... del menú.
 C - Barra de navegación - La barra de navegación proporciona una manera conveniente para

moverse por los archivos y carpetas que componen el proyecto. Al hacer clic en un elemento en la barra de
navegación se desplegará un menú con las subcarpetas y archivos en ese lugar listo para la
selección. Esto proporciona una alternativa a la ventana de herramientas Proyecto.
 D - Ventana Editor - La ventana del editor muestra el contenido del archivo en el que el desarrollador
está trabajando actualmente. Lo que se muestra en esta ubicación, sin embargo, está sujeta a
contexto. Durante la edición de código, por ejemplo, aparecerá el editor de código. Cuando se trabaja en un
archivo de diseño de interfaz de usuario, por el contrario, aparecerá la herramienta de interfaz de usuario
de Designer. Cuando hay varios archivos abiertos, cada archivo está representado por una pestaña situada
a lo largo del borde superior del editor, como se muestra en la Figura 4-3.
Figura 4-3
 E - Barra de estado - La barra de estado muestra mensajes informativos sobre el proyecto y las
actividades de Android estudio junto con el botón de menú de herramientas situada en la esquina
izquierda. Al pasar por encima los elementos de la barra de estado proporcionará una descripción de ese
campo. Muchos campos son interactivos, lo que permite al usuario hacer clic para realizar tareas u obtener
información de estado más detallada.
 F - Proyecto Ventana Herramienta - La ventana de herramientas del proyecto proporciona una visión
jerárquica de la estructura de archivos de proyecto que permite la navegación a los archivos y carpetas
específicas a realizar.
La ventana de herramientas del proyecto es sólo uno de una serie de ventanas de herramientas disponibles en
el entorno Android Studio.
La herramienta de Windows
Además de la ventana de herramientas vista del proyecto, Android Studio también incluye una serie de otras
ventanas que, cuando está activada, se muestran en la parte inferior y los lados de la ventana principal. El menú
de acceso rápido ventana de herramientas se puede acceder con solo pasar el puntero del ratón sobre el botón
situado en la esquina izquierda de la barra de estado (Figura 4-4) sin hacer clic en el botón del ratón.
Figura 4-4
Al seleccionar un elemento en el menú de acceso rápido hará que la ventana de la herramienta correspondiente
que aparezca dentro de la ventana principal.
Por otra parte, un conjunto de barras de la ventana de la herramienta se puede visualizar haciendo clic en el
icono de menú de acceso rápido en la barra de estado. Estas barras aparecen a lo largo de la izquierda,
derecho e inferior de los bordes de la ventana principal (como se indica por las flechas en la Figura 4-5) y
contienen botones para mostrar y ocultar cada una de las ventanas de herramientas. Cuando se muestran los
barrotes de la ventana de herramientas, un segundo clic en el botón en la barra de estado ocultarlos.
Figura 4-5
Al hacer clic en un botón se mostrará la ventana de la herramienta correspondiente, mientras que un segundo
clic, se oculta la ventana. Botones prefijados con un número (por ejemplo 1: Proyecto) indican que la ventana de
la herramienta también puede visualizarse pulsando la tecla Alt en el teclado (o la tecla Comando para Mac OS
X), junto con el número correspondiente.
La ubicación de un botón en una barra de la ventana de la herramienta indica el lado de la ventana contra la que
aparecerá la ventana cuando se muestran. Estas posiciones pueden ser cambiados haciendo clic y arrastrando
los botones para diferentes ubicaciones en otras barras de herramientas de la ventana.
Cada ventana de la herramienta tiene su propia barra de herramientas a lo largo del borde superior. Los botones
dentro de estas barras de herramientas varían de una herramienta a otra, aunque todas las ventanas de
herramientas contienen una opción de configuración, representada por el icono de la rueda dentada, que
permite a los diversos aspectos de la ventana para ser cambiados. Figura 4-6 muestra el menú de configuración
de la ventana de herramientas vista del proyecto. Las opciones están disponibles, por ejemplo, para desacoplar
una ventana y les permiten flotar fuera de los límites de la ventana principal de Android Studio.
Figura 4-6
Todas las ventanas también incluyen un botón a la derecha de la barra de herramientas proporciona una forma
adicional para ocultar la ventana de herramientas de la vista. Android Studio ofrece una amplia gama de
ventanas de herramientas de la ventana, el más utilizado de los cuales son los siguientes:
 Proyecto - La vista del proyecto proporciona una visión general de la estructura de archivos que
componen el proyecto que permite una rápida navegación entre archivos. En general, hacer doble clic en
un archivo en la ventana del proyecto hará que el archivo a ser cargado en la herramienta de edición
apropiado.
 Estructura - La estructura herramienta proporciona una visión de alto nivel de la estructura del archivo
de origen que se muestra actualmente en el editor. Esta información incluye una lista de elementos, tales
como clases, métodos y variables en el archivo. Al seleccionar un elemento de la lista estructura le llevará a
ese lugar en el archivo de origen en la ventana del editor.
 Favoritos - Una variedad de artículos del proyecto se pueden agregar a la lista de favoritos. Al hacer
clic derecho sobre un archivo en la ventana de proyecto, por ejemplo, ofrece acceso a una opción de menú
Agregar a Favoritos. Del mismo modo, un método en un archivo de código fuente se puede agregar como
favorito haciendo clic derecho sobre ella en la ventana Estructura herramienta. Cualquier cosa se añade a
una lista de Favoritos se puede acceder a través de esta ventana Favoritos herramienta.
 Construir Las variantes - La acumulación variantes ventana de herramientas proporciona una forma
rápida de configurar diferentes tipos de generación para el proyecto actual de la aplicación (por ejemplo,
diferentes formaciones para la depuración y liberar versiones de la aplicación, o múltiples compilaciones
para dirigirse a diferentes categorías de dispositivos).
 TODO - Como su nombre indica, esta herramienta proporciona un lugar para revisar los artículos que
aún no se han completado en el proyecto. Android Studio compila esta lista mediante el escaneo de los
archivos de origen que componen el proyecto para buscar comentarios que coinciden con los patrones
especificados TODO. Estos patrones se pueden revisar y cambiar seleccionando Archivo ->
Configuración ... opción de menú y navegar a la página TODO enumerados en Configuración IDE.
 Mensajes - La herramienta de mensajes de registros de las ventanas de salida del sistema de

construcción Gradle (Gradle es el sistema subyacente utilizado por Android Estudio para la construcción de
las diferentes partes de los proyectos en un aplicaciones ejecutables) y puede ser útil para identificar las
causas de los problemas de compilación al compilar proyectos de aplicación .
 Android - El ventana de la herramienta Android proporciona acceso al sistema de depuración

Android. Dentro de esta ventana tareas como resultado del registro de monitoreo de una aplicación que se
ejecuta, tomar capturas de pantalla y vídeos de la aplicación, detener un proceso y realizar tareas básicas
de depuración se puede realizar.
 Terminal - Proporciona acceso a una ventana de terminal en el sistema en el que Android se ejecuta
Studio. En los sistemas Windows es la interfaz de línea de comandos, mientras que en los sistemas Linux y
Mac OS X, esto toma la forma de un símbolo del Terminal.
 Ejecutar - La ventana de herramientas de ejecución esté disponible cuando una aplicación se está
ejecutando actualmente y ofrece una vista de los resultados de la ejecución junto con opciones de parar o
reiniciar un proceso en ejecución. Si una aplicación está fallando para instalar y ejecutar en un dispositivo o
emulador, esta ventana suelen proporcionar información de diagnóstico relacionada con el problema.
 Registro de eventos - La ventana de registro de eventos muestra los mensajes relacionados con
eventos y actividades que se realizan dentro de Android Studio. La construcción con éxito de un proyecto,
por ejemplo, o el hecho de que una aplicación se está ejecutando ahora se informará dentro de esta
herramienta de ventana.
 Gradle Console - La consola Gradle se utiliza para mostrar toda la salida del sistema Gradle como
proyectos se construyen desde dentro Android Studio. Esto incluirá información sobre el éxito o el fracaso
del proceso de construcción junto con los detalles de los errores o advertencias.
 Maven Proyectos - Maven es una gestión de proyectos y construcción de sistema diseñado para
facilitar el desarrollo de proyectos basados en Java complejas y se superpone en muchas zonas con la
funcionalidad proporcionada por Gradle. Google ha elegido Gradle como el sistema de construcción
subyacente para el desarrollo de Android, por lo menos que ya están familiarizados con Maven o tienen
proyectos Maven existentes para importar, el tiempo será mejor invertido el aprendizaje y la adopción
Gradle para sus proyectos. La ventana de herramientas proyectos Maven se puede utilizar para agregar,
administrar y Maven importación proyectos basados en Android Studio.
 Gradle - La ventana de la herramienta Gradle proporciona una vista en las tareas Gradle que
conforman la configuración de construcción del proyecto. La ventana muestra las tareas que están
involucrados en la compilación de los diversos elementos del proyecto en una aplicación ejecutable. Haga
clic derecho en una tarea de primer nivel Gradle y seleccione la opción de menú Abrir Gradle Config para
cargar el Gradle construir archivo para el proyecto actual en el editor. Gradle se cubrirá con mayor detalle
más adelante en este libro.
 Comandante - La herramienta de ventana Comandante puede ser mejor descrito como una
combinación de las ventanas del proyecto y estructura de herramientas, lo que permite la jerarquía de
archivos del proyecto se va a desplazar y de los distintos elementos que componen las clases para ser
inspeccionado y se carga en el editor o diseñador ventanas.
 Diseñador - Disponible cuando el diseñador de interfaces está activa, esta ventana de herramientas
proporciona acceso a los paneles de árbol de componentes y propiedades del diseñador.
Atajos de teclado Android Studio
Android Studio incluye una gran cantidad de atajos de teclado diseñados para ahorrar tiempo al realizar tareas
comunes. Un listado completo mapa de teclas de acceso directo del teclado se puede ver e imprimir desde la
ventana del proyecto Android Estudio seleccionando la Ayuda -> opción de menú de referencia por defecto de
configuración de teclado.
Switcher y archivos recientes Navegación

Otro mecanismo útil para navegar dentro de la ventana principal de Android estudio implica el uso de la
Switcher. Acceder a través de la combinación de teclas Ctrl-Tab, el conmutador aparece como un panel de lista
tanto las ventanas de herramientas y archivos actualmente abiertos (Figura 4-7).
Figura 4-7
Una vez que aparece, el conmutador permanecerá visible durante todo el tiempo la tecla Ctrl sigue
deprimida. Tocando repetidamente la tecla Tab mientras mantiene pulsada la tecla Ctrl ciclo voluntad a través
de las distintas opciones de selección, mientras que soltar la tecla Ctrl causa del control seleccionado para ser
seleccionados y se muestran dentro de la ventana principal.
Además de la conmutación, la navegación a los archivos abiertos recientemente es proporcionada por el panel
de archivos recientes (Figura 4-8). Esto se puede acceder utilizando el atajo de teclado Ctrl-E (Cmd-E en Mac
OS X). Una vez que aparece, ya sea el puntero del ratón se puede usar para seleccionar una opción o, en su
defecto, las teclas de flecha del teclado se pueden utilizar para desplazarse por las opciones de nombre de
archivo y de la ventana de herramientas. Al pulsar la tecla ENTER para seleccionar el elemento resaltado.
Figura 4-8
Cambiar el tema Android Estudio

El tema general del entorno Android estudio se puede cambiar desde la pantalla de bienvenida mediante
Configurar -> Configuración de la opción, o por medio del Archivo -> Configuración ... opción de menú de la
ventana principal. Una vez que aparezca el diálogo de configuración, seleccione la opción Apariencia en el panel
de la izquierda y luego cambiar la configuración del menú del tema antes de hacer clic en el botón Aplicar. Los
temas disponibles en la actualidad consisten en IntelliJ, Windows y Darcula. La Figura 4-9 muestra un ejemplo
de la ventana principal con el tema Darcula seleccionado:
Figura 4-9
Resumen
Los elementos principales del entorno de Android estudio consisten en la pantalla de bienvenida y ventana
principal. Cada proyecto abierto se le asigna su propia ventana principal, que, a su vez, consiste en una barra de
menús, barra de herramientas, la edición y el área de diseño, barra de estado y una colección de ventanas de
herramientas. Ventanas de herramientas aparecen en los lados y bordes inferiores de la ventana principal y se
puede acceder ya sea usando el menú de acceso rápido situada en la barra de estado, oa través de los barrotes
de la ventana de herramientas opcionales.
Hay muy pocas acciones dentro Android estudio que no se pueden activar a través de un atajo de teclado. Un
mapa de teclas de atajos de teclado por defecto se puede acceder en cualquier momento desde la ventana
principal de Android Studio.
4 Creación de un dispositivo virtual de Android (AVD) en

Android Estudio
En el curso del desarrollo de aplicaciones de Android en Android estudio será necesario para compilar y ejecutar
una aplicación varias veces. Una aplicación Android puede ser probado por la instalación y ejecución que sea en
un dispositivo físico o en un dispositivo virtual (AVD) entorno emulador de Android. Antes de que una AVD se
puede utilizar, primero debe ser creado y configurado para que coincida con la especificación de un modelo de
teléfono. El objetivo de este capítulo, por lo tanto, es trabajar a través de los pasos necesarios para crear un
dispositivo virtual, utilizando la tableta Nexus 7 como un ejemplo de referencia
Acerca de los dispositivos virtuales de Android

AVDs son esencialmente los emuladores que permiten a las aplicaciones de Android a ensayar sin la necesidad
de instalar la aplicación en un dispositivo basado en Android física. Un AVD puede estar configurado para
emular una variedad de características de hardware incluyendo opciones tales como tamaño de pantalla,
capacidad de memoria y la presencia o no de características tales como una cámara, soporte de navegación
GPS o un acelerómetro. Como parte de la instalación estándar Android de estudio, una serie de plantillas
emulador se instalan permitiendo AVDs a ser configurados para una gama de diferentes dispositivos. Plantillas
adicionales pueden ser cargados o configuraciones personalizadas creadas para combinar con cualquier
dispositivo Android física especificando las propiedades tales como el tipo de procesador, capacidad de
memoria y el tamaño y la densidad de píxeles de la pantalla. Consulte la documentación de desarrolladores en
línea para su dispositivo para saber si las definiciones de emulador están disponibles para su descarga e
instalación en el medio ambiente AVD.
Cuando se inicia, una AVD aparecerá como una ventana que contiene un entorno de dispositivos Android
emulado. Figura 5-1, por ejemplo, muestra una sesión de AVD configurado para emular el dispositivo Google
Nexus 7. Nuevos AVDs se crean y administran mediante el Administrador de dispositivos virtuales Android, que
puede utilizarse en modo de línea de comandos o con una interfaz gráfica de usuario fácil de usar más.
Creación de una nueva AVD

Con el fin de probar el comportamiento de una aplicación, será necesario crear un AVD para una configuración
de dispositivo de Android específico.
Para crear una nueva AVD, el primer paso es poner en marcha el Administrador de AVD. Esto se puede lograr
desde el entorno de Android Estudio seleccionando las Herramientas -> Android -> opción de menú AVD
Manager desde dentro de la ventana principal. Alternativamente, la herramienta puede ser lanzado desde una
terminal o de línea de comandos con el siguiente comando:
avd androide
Una vez puesto en marcha, aparecerá la herramienta como se indica en la Figura 5-2. Asumiendo una nueva
instalación del SDK de Android, actualmente se listarán no AVDs:
Figura 5-2
Comience el proceso de creación AVD haciendo clic en el botón Nuevo ... para invocar el cuadro de diálogo
Crear un nuevo dispositivo virtual de Android (AVD). En el cuadro de diálogo, realice los siguientes pasos para
crear un emulador compatible Nexus primera generación 7:
1. Introduzca un nombre descriptivo (por ejemplo Nexus7) en el campo Nombre. Tenga en cuenta que los
espacios y otros caracteres especiales no están permitidos en el nombre. 2. Establecer el menú de dispositivos
para Nexus 7 (2012) (7.0 ", 800 x 1280: tvhdpi). 3. Establecer el menú Destino para Android 4.4 - Nivel API 19.
4. Ajuste el menú CPU / ABI a ARM (armeabi-v7a). 5. Establecer el menú de la piel de "sin piel" para que el
dispositivo se muestra sin controles de hardware simulados. 6. Deje el valor RAM por defecto en las opciones de
memoria y el valor de almacenamiento interno sin cambios de la configuración predeterminada. Tenga en
cuenta sin embargo, que puede ser necesario para reducir el valor de RAM por debajo 768M en sistemas
Windows con menos memoria disponible. 7. Si el equipo host contiene una web cam la cámara frontal:
emulación puede ser configurado para utilizar esta cámara.Alternativamente, una cámara emulado puede ser
seleccionado. Si funcionalidad de la cámara no es requerido por la aplicación, simplemente deje este conjunto
en Ninguno.
Independientemente de si se habilita la presente opción de teclado de hardware es una cuestión de preferencia
personal. Cuando se selecciona la opción de teclado de hardware, será posible utilizar el teclado físico en el
sistema en el que se ejecuta el emulador. Como tal, el teclado de software Android no aparecerá en el emulador
cuando la introducción de texto es requerido por una aplicación en ejecución.
Tenga en cuenta que también puede ser posible para acelerar el rendimiento del emulador activando la opción
GPU Uso Host. En el caso de que el emulador se bloquea durante el arranque cuando se selecciona esta
opción, edite las propiedades de los dispositivos virtuales y desactivar esta opción. Figura 5-3 ilustra el diálogo
con los ajustes adecuados, aplicados por un emulador de Nexus 7. Una vez que los ajustes de configuración se
han completado, haga clic en el botón Aceptar.
Figura 5-3
Con la AVD creado, la AVD Manager ahora se puede cerrar. Si las futuras modificaciones de la AVD son
necesarios, simplemente vuelva a abrir el Administrador de AVD, seleccione la AVD de la lista y haga clic en el
botón Editar ....
Inicio del emulador

Para realizar una prueba de funcionamiento del emulador AVD de nueva creación, sólo tiene que seleccionar el
emulador desde el Administrador de AVD y haga clic en el botón Start ... seguido por el lanzamiento en el
cuadro de diálogo Opciones de lanzamiento resultante. El emulador aparecerá en una nueva ventana y,
después de un corto período de tiempo, el logotipo de "androide" aparecerá en el centro de la pantalla. La
primera vez que el emulador se ejecuta, puede tardar hasta 10 minutos para que el emulador se cargue por
completo y empezar. En las invocaciones posteriores, esto normalmente se reducirá a unos minutos. En el caso
de que el tiempo de arranque del sistema es considerable, no dude en dejar el emulador corriendo. El sistema
detectará que ya se está ejecutando y se adhieren a ella cuando se ponen en marcha las aplicaciones, lo que
ahorra una cantidad considerable de tiempo de inicio.
Otra opción cuando se utiliza el emulador es para activar la opción de instantáneas en la pantalla de
configuración AVD. Esta opción, que sólo se puede utilizar cuando la opción Host GPU uso está desactivado,
permite que el estado de una instancia AVD se salven y vuelve a cargar próxima vez que se puso en
marcha. Esto puede resultar en un tiempo de arranque emulador de unos pocos segundos.
Cuando el uso de instantáneas, asegúrese de que el lanzamiento de la imagen y guardar a Snapshot opciones
están habilitados en el cuadro de diálogo Opciones de lanzamiento. La primera vez que una instancia del
emulador se inicia con instantáneas habilitada, la AVD comenzará en la forma acostumbrada.Al cerrar la
ventana del emulador, un ligero retraso ocurrirá mientras se guarda el estado de la AVD. La próxima vez que el
emulador se lanzó una se carga más rápidamente y volver al estado guardado previamente.
Para revertir la AVD a su, estado previo a la instantánea original, simplemente un lanzamiento con el
lanzamiento de la opción instantánea desactivada.
Para ahorrar tiempo en la siguiente sección de este capítulo, dejar el emulador corriendo antes de continuar.
Ejecutar la aplicación en la AVD

Con un emulador AVD configurado, el ejemplo de aplicación AndroidSample creado en el capítulo anterior ya se
puede compilar y ejecutar. Con el proyecto AndroidSample cargado en Android de estudio, simplemente haga
clic en el botón de ejecución representado por un triángulo verde ubicado en la barra de herramientas de
Android Studio como se muestra en la Figura 5-4 a continuación, seleccione la opción Ejecutar -> opción
Ejecutar ... del menú o utilizar las teclas Shift + F10 atajo de teclado:
Figura 5-4
Por defecto, Android Estudio responderá a la solicitud de ejecución mediante la visualización del diálogo
Seleccionar dispositivo. Esto ofrece la opción para ejecutar la aplicación en una instancia AVD que ya está en
marcha, o para iniciar una nueva sesión de AVD específicamente para esta aplicación. Figura 5-5 muestra el
creado previamente Nexus7 AVD como un dispositivo que ejecuta como resultado de los pasos realizados en la
sección anterior. Con este dispositivo seleccionado en el cuadro de diálogo, haga clic en Aceptar para instalar y
ejecutar la aplicación en el emulador.
Figura 5-5
Una vez instalada la aplicación en funcionamiento, la interfaz de usuario para la clase AndroidSampleActivity
aparecerá en el emulador:
Figura 5-6
En el caso de que la actividad no se inicia automáticamente, puedes ver si el icono de inicio ha aparecido entre
las aplicaciones en el emulador. Si es así, simplemente haga clic en él para iniciar la aplicación. Una vez que
comienza el proceso de ejecución, de gestión y Android ventanas de herramientas estarán disponibles. La
ventana de la herramienta Ejecutar mostrará información de diagnóstico como el paquete de aplicación se
instala y se inicia. Figura 5-7 muestra la salida de la ventana de herramientas Ejecutar en un lanzamiento de la
aplicación con éxito:
Figura 5-7
Si surgen problemas durante el proceso de lanzamiento, la herramienta Ejecutar proporcionará información que
se espera ayude a aislar la causa del problema.
Suponiendo que se carga la aplicación en el emulador y se ejecuta como se esperaba, se han verificado con
seguridad que el entorno de desarrollo de Android está instalado y configurado correctamente.
Ejecutar / depurar Configuraciones

Un proyecto en particular se puede configurar de tal manera que un dispositivo o emulador específico se utiliza
de forma automática cada vez que se ejecuta desde Android Studio. Esto evita la necesidad de hacer una
selección en el selector de dispositivo cada vez que se ejecuta la aplicación. Revisar y modificar la configuración
Ejecutar / Depurar, haga clic en el botón a la izquierda del botón de ejecución en la barra de herramientas
Android Studio y seleccione Editar Configuraciones ... opción en el menú resultante:
Figura 5-8
En el cuadro de diálogo Ejecutar / Depurar configuraciones, la aplicación puede configurarse para utilizar
siempre un emulador preferido activando la opción Emulador enumerados en la sección Dispositivo de destino y
seleccionar el emulador desde el menú desplegable. Figura 5-9, por ejemplo, muestra la aplicación
AndroidSample configurado para ejecutarse de forma predeterminada en el emulador Nexus7 creado
anteriormente:
Figura 5-9
Detener una aplicación en ejecución

Cuando la construcción y ejecución de una aplicación con fines de prueba, cada vez que una nueva revisión de
la aplicación se compila y ejecuta, la instancia anterior de la aplicación que se ejecuta en el dispositivo o
emulador se dará por terminado de forma automática y se reemplaza con la nueva versión. También es posible,
sin embargo, para detener manualmente una aplicación que se ejecuta desde dentro Android Studio.
Para detener una aplicación en ejecución, empezar por mostrar la ventana de la herramienta Android, ya sea
usando el botón de la barra de la ventana, o por medio del menú de acceso rápido (invocado moviendo el
puntero del ratón sobre el botón en la esquina izquierda de la barra de estado, como se muestra en la Figura 5
-10).
Figura 5-10
Una vez que aparezca la ventana de herramientas Android, asegúrese de que los dispositivos | ADB Registros
pestaña se ha seleccionado, y que se ha seleccionado la entrada Emulador Nexus7 en el panel de
dispositivos. En la lista de procesos situados debajo del nombre del dispositivo, busque y seleccione el proceso
androidsample como se indica en la Figura 5-11:
Figura 5-11
Con el proceso de seleccionar, detenerla haciendo clic en el botón rojo Finalizar aplicación en la barra de
herramientas vertical a la izquierda de la lista de procesos:
Una alternativa al uso de la ventana de herramientas Android es abrir el Android Debug Monitor. Esto puede ser
lanzado a través de las Herramientas -> Android -> opción de menú Monitor de dispositivos Android. Una vez
puesto en marcha, el proceso se puede seleccionar de la lista (Figura 5-13) y terminó haciendo clic en el botón
rojo de parada ubicada en la barra de herramientas superior de la lista.
Figura 5-13
De línea de comandos AVD Creación

Como se discutió previamente, además de la interfaz gráfica de usuario también es posible crear un nuevo AVD
directamente desde la línea de comandos.Esto se consigue utilizando la herramienta androide junto con algunas
opciones de línea de comandos. Una vez iniciada, la herramienta solicitará información adicional antes de crear
la nueva AVD.
Suponiendo que el sistema ha sido configurado de tal manera que el directorio de herramientas SDK de Android
está incluido en la variable de entorno PATH, una lista de destinos disponibles para la nueva AVD se puede
obtener emitiendo el siguiente comando en una ventana de terminal o el comando:
objetivos lista android
La salida resultante del comando anterior contendrá una lista de las versiones del SDK de Android que están
disponibles en el sistema. Por ejemplo:
Disponible objetivos Android:

----------
id: 1 o "android-19"
Nombre: Android 4.4
Tipo: Plataforma
Nivel de la API: 19
Revisión: 1
Skins: HVGA, QVGA, WQVGA400, WQVGA432, WSVGA, WVGA800 (por defecto), WVGA854,
WXGA720, WXGA800, WXGA800-7in
ABIs: armeabi-V7A
La sintaxis para la creación de AVD es como sigue:
Android crear avd -n <nombre> -t <targetID> [- <option> <valor>]
Por ejemplo, para crear un nuevo AVD llamado Nexus7 utilizando el ID de destino para el dispositivo Android 4.4
API nivel 19 (en este caso Identificación del 1), el siguiente comando se puede utilizar:
androide crear avd -n Nexus7 -t 1

La herramienta androide creará la nueva AVD a las especificaciones requeridas para un dispositivo básico de
Android 4.4, que también proporciona la opción de crear una configuración personalizada para que coincida con
la especificación de un dispositivo específico si es necesario. Una vez que una nueva AVD se ha creado a partir
de la línea de comandos, no puede aparecer en la herramienta Administrador de dispositivos Android hasta que
se hace clic en el botón Actualizar.
Además de la creación de nuevos AVDs, un número de otras tareas se puede realizar desde la línea de
comandos. Por ejemplo, una lista de los disponibles en la actualidad AVDs se puede obtener utilizando la lista
avd argumentos de la línea de comandos:
lista androide avd
C: \ Users lista \ nas> androide avd

Disponible dispositivos virtuales Android:
---------
Nombre: KindleFireHD7
Ruta de acceso: C: \ Users \ nas \ .android \ avd \ KindleFireHD7.avd
Objetivo: Kindle Fire HD 7 "(Amazon)
Basado en Android 4.0.3 (nivel de API 15)
ABI: armeabi-v7a
Piel: 800x1280
---------
Nombre: Nexus7
Ruta de acceso: C: \ Users \ nas \ .android \ avd \ Nexus7.avd
Objetivo: Android 4.4 (nivel de API 19)
ABI: armeabi-v7a
Piel: 800x1280
---------
Nombre: Nexus7Google
Ruta de acceso: C: \ Users \ nas \ .android \ avd \ Nexus7Google.avd
Objetivo: API de Google (Google Inc.)
Basado en Android 4.2.2 (nivel de API 17)
ABI: armeabi-v7a
Piel: 800x1280
Del mismo modo, para eliminar una AVD existente, basta con utilizar la opción de eliminación de la siguiente
manera:
Android eliminar avd -name <avd nombre>
Archivos de configuración de dispositivos virtuales de Android

De forma predeterminada, los archivos asociados a una AVD se almacenan en el subdirectorio .android / avd del
directorio home del usuario, cuya estructura es la siguiente (donde <avd nombre> se sustituye por el nombre
asignado a la AVD):
<Nombre avd> .avd / config.ini

<Avd nombre> .avd / userdata.img
<Nombre avd> .ini
El archivo config.ini contiene los parámetros de configuración de dispositivos, tales como dimensiones de la
pantalla y memoria especificados durante el proceso de creación de AVD. Estos ajustes se pueden cambiar
directamente en el archivo de configuración y se adoptarán por la AVD cuando se invoca al lado.
El <nombre avd> .ini contiene una referencia al objetivo SDK de Android y la ruta a los archivos de AVD. Tenga
en cuenta que también necesitará un cambio en el valor image.sysdir en el archivo config.ini que se refleja en el
valor objetivo de este archivo.
Mover y Cambiar el nombre de un dispositivo virtual de Android

El nombre actual o la ubicación de los archivos AVD pueden alterarse desde la línea de comandos con el
argumento movimiento avd de la herramienta de android. Por ejemplo, para cambiar el nombre de una AVD
llamado Nexus7 a Nexus7B, el siguiente comando se puede ejecutar:
android movimiento avd -n -r Nexus7 Nexus7B

Para trasladar físicamente los archivos asociados a la AVD, la siguiente sintaxis del comando se debe utilizar:
movimiento androide avd -n <avd nombre> -p <ruta de acceso a la nueva ubicación>
Por ejemplo, para mover un AVD desde su ubicación actual sistema de archivos en / tmp / Nexus7Test:
android movimiento avd -n Nexus7 -p / tmp / Nexus7Test
Tenga en cuenta que el directorio de destino no debe existir ya antes de ejecutar el comando para mover un
AVD.
Resumen
Un proceso de desarrollo de aplicación típica sigue un ciclo de codificar, compilar y ejecutar en un entorno de
prueba. Aplicaciones de Android se pueden ensayar ya sea en un dispositivo Android físico o el uso de un
dispositivo virtual (AVD) emulador de Android. AVDs se crean y administran mediante la herramienta
Administrador Android AVD que puede ser utilizado como una herramienta de línea de comandos o mediante
una interfaz gráfica de usuario. Al crear un AVD para simular un modelo específico de dispositivo Android es
importante que el dispositivo virtual puede configurar con una especificación de hardware que coincide con el
del dispositivo físico.
5 Prueba Android Apps Estudio en un dispositivo Android

Física
Mientras que se puede lograr mucho por probar aplicaciones utilizando un dispositivo virtual de Android
(AVD), no hay sustituto para la realización de pruebas de aplicaciones del mundo real en un dispositivo Android
física y hay una serie de características de Android que sólo están disponibles en los dispositivos Android
físicas. La comunicación con ambas instancias AVD y dispositivos Android conectados es manejado por el
Puente de depuración Android (BAD). En este capítulo vamos a trabajar a través de los pasos para configurar el
entorno adb para permitir pruebas de aplicaciones en un dispositivo Android físico con los sistemas basados en
Mac OS X, Windows y Linux.
Una visión general del Android depuración Bridge (ADB)

El propósito principal de la ADB es facilitar la interacción entre un sistema de desarrollo, en este caso
Android de estudio, y ambos emuladores AVD y dispositivos Android físicas a efectos de ejecución y depuración
de aplicaciones.
El Banco Asiático de Desarrollo consta de un cliente, un proceso de servidor que se ejecuta en segundo plano
en el sistema de desarrollo y un proceso de fondo demonio que se ejecuta en cualquiera de AVDs o dispositivos
Android reales tales como teléfonos y tabletas.
El cliente ADB puede tomar una variedad de formas. Por ejemplo, un cliente se proporciona en forma de una
herramienta de línea de comandos denominada adb ubicado en el subdirectorio de plataforma-herramientas
SDK de Android. Del mismo modo, Android Studio también tiene un cliente incorporado.
Una variedad de tareas se puede realizar mediante la herramienta de línea de comandos adb. Por ejemplo, una
lista de los dispositivos físicos o virtuales actualmente activos se puede obtener usando el argumento de
dispositivos de línea de comandos. La siguiente salida del comando indica la presencia de un AVD en el sistema
pero no hay dispositivos físicos:
$ adb devices
Lista de los dispositivos conectados
dispositivo emulador-5554
Habilitación de ADB en Android 4.4 dispositivos basados

Antes de ADB puede conectarse a un dispositivo Android, ese dispositivo debe estar configurado para permitir la
conexión. En los dispositivos de teléfonos y tabletas con Android 4.4 o posterior, los pasos para lograr esto son
los siguientes:
1. Abra las configuraciones de aplicación en el dispositivo y seleccione la tableta Acerca de Acerca de opción o
teléfono.
2. En la pantalla Acerca de, desplácese hacia abajo hasta el campo del número de Build (Figura 6-1) y puntee
en él siete veces hasta que aparezca un mensaje indicando que el modo de programador se ha habilitado.
Figura 6-1
3. Vuelva a la pantalla principal de configuración y observe la aparición de una nueva opción titulada opciones
Developer. Seleccione esta opción y localizar el ajuste en la depuración USB titulado pantalla
desarrollador. Active la casilla de verificación junto a este elemento como se ilustra en la Figura 6-2 para permitir
la conexión de depuración adb.
Figura 6-2
4. Pase hacia abajo desde la parte superior de la pantalla para mostrar el panel de notificaciones (Figura 6-3) y
tenga en cuenta que el dispositivo está conectado actualmente como un dispositivo multimedia.
Figura 6-3
5. Seleccione la entrada de una notificación dispositivo de medios y en el panel resultante (Figura 6-4) cambiar
el tipo de conexión a la cámara (PTP).
Figura 6-4
En este punto, el dispositivo está configurado para aceptar conexiones de depuración de adb en el sistema de
desarrollo. Todo lo que queda es configurar el sistema de desarrollo para detectar el dispositivo cuando está
conectado. Si bien este es un proceso relativamente sencillo, los pasos a seguir difieren dependiendo de si el
sistema de desarrollo se está ejecutando Windows, Mac OS X o Linux. Tenga en cuenta que los siguientes
pasos se supone que el directorio de la plataforma de herramientas SDK de Android está incluido en la variable
de entorno PATH del sistema operativo como se describe en el capítulo titulado La creación de un entorno de
desarrollo de Android.
Mac OS X configuración ADB

Con el fin de configurar el entorno de ADB en un sistema Mac OS X, conecte el dispositivo al sistema de
computadora con un cable USB, abra una ventana de terminal y ejecute el siguiente comando:
adb actualización de Android
A continuación, reinicie el servidor adb emitiendo los siguientes comandos en la ventana de terminal:
$ Kill-servidor adb
$ Start-servidor adb
* Daemon no se está ejecutando. empezando ahora en el puerto 5037 *
* Daemon inició correctamente *
Una vez que el servidor se ejecuta con éxito, ejecute el siguiente comando para comprobar que el dispositivo se
ha detectado:
$ adb devices
74CE000600000001 offline
Si el dispositivo aparece como fuera de línea, vaya al dispositivo Android y comprobar la presencia del diálogo
que se muestra en la Figura 6-9 pedir permiso para permitir una depuración USB. Active la casilla junto a la
opción que dice permite Siempre desde este equipo, antes de hacer clic en Aceptar. Repitiendo el comando adb
devices ahora debe enumerar el dispositivo como disponibles:

Dispositivo 015d41d4454bf80c
En el caso de que el dispositivo no está en la lista, trate de salir de la sesión y luego de nuevo en el escritorio de
Mac OS X y, si el problema persiste, reiniciar el sistema.
Configuración de Windows ADB

El primer paso para configurar un sistema de desarrollo basado en Windows para conectarse a un dispositivo
Android usando ADB es instalar los controladores USB correspondientes en el sistema. En el caso de algunos
dispositivos, el controlador USB de Google debe estar instalado (una lista completa de dispositivos compatibles
con el controlador USB Google se puede encontrar en línea en http://developer.android.com/sdk/win-usb.html ).
Para instalar este controlador, realice los siguientes pasos:
 Inicie Android Studio y abra el Administrador de SDK de Android, ya sea seleccionado Configurar ->
Gestor de SDK desde la pantalla de bienvenida, o el uso de las Herramientas -> Android -> SDK
opción de menú Administrador cuando se trabaja en un proyecto existente.
 Vaya a la sección de Extras y comprobar el estado del paquete USB Driver Google para asegurarse de
que está catalogado como Instalado.
 Si no está instalado el controlador, seleccione y haga clic en el botón Instalar paquetes para iniciar la
instalación.
 Una vez completada la instalación, cierre el Administrador de Android SDK.
Para dispositivos Android no soportados por el controlador USB Google, será necesario descargar los
controladores proporcionados por el fabricante del dispositivo. Un listado de los controladores y la información
de descarga se puede obtener en línea en http://developer.android.com/tools/extras/oem-usb.html .
Cuando un dispositivo Android está conectado a un sistema Windows se configura como un dispositivo
portátil. Para que el dispositivo para conectarse a ADB debe configurarse como un dispositivo Android ADB
Composite. En primer lugar, conecte el dispositivo Android en el sistema informático si no está conectado
actualmente. A continuación, mostrar el Panel de control y seleccione Administrador de dispositivos. En el
diálogo que aparece, compruebe si hay una categoría denominada Otros dispositivos. Despliegue esta categoría
y comprobar para ver si el dispositivo Android está en la lista (en el caso de la figura 6-5, un Nexus 7 ha sido
detectado):
Figura 6-5
Haga clic en el nombre del dispositivo y seleccione Actualizar software de controlador en el menú. Seleccione la
opción Buscar en mi sistema software de controlador y en el siguiente cuadro de diálogo, mantenga la opción
Incluir subcarpetas seleccionadas y haga clic en el botón Examinar .... Vaya a la ubicación en la que se han
instalado los controladores USB. En el caso de que el controlador USB Google, esto será en el sdk \ extras \
google \ USB_Driver subcarpeta del directorio de instalación de Android Studio (cuya ubicación se encuentra en
el SDK Manager). Una vez localizado, haga clic en Aceptar para seleccionar la carpeta del controlador seguido
en Siguiente para iniciar la instalación. Durante la instalación, aparecerá un mensaje de seguridad de Windows
aparecerá pidiendo permiso para instalar el controlador como se ilustra en la Figura 6-6. Cuando aparezca este
cuadro de diálogo, haga clic en el botón Instalar para continuar.
Figura 6-6
Una vez finalizada la instalación, la pantalla de actualización del controlador de Windows se actualizará para
mostrar un mensaje que indica que el controlador se ha instalado y que el dispositivo está ahora reconocido
como un ADB Interface Android Compuesto:
Figura 6-7
Volver al Administrador de dispositivos y tenga en cuenta que el dispositivo ya no aparece en Otros dispositivos
y ahora se clasifica como un ADB Composite interfaz Android. Figura 6-8, por ejemplo, muestra la entrada del
dispositivo para una tableta Nexus 7 usando el controlador USB Google.
Figura 6-8
Con los controladores instalados y el dispositivo ahora se reconocen como el tipo de dispositivo correcto, abra
una ventana del símbolo del sistema y ejecute el siguiente comando:
adb devices
Este comando debe información de salida del dispositivo conectado similar a la siguiente:
015d41d4454bf80c offline
Si el dispositivo aparece como desconectado o no autorizado, vaya a la pantalla del dispositivo y compruebe si
el diálogo que se muestra en la Figura 6-9 pedir permiso para permitir una depuración USB.
Figura 6-9
Active la casilla junto a la opción que dice permite Siempre desde este equipo, antes de hacer clic en
Aceptar. Repitiendo el comando adb devices ahora debe enumerar el dispositivo que está listo:

Dispositivo 015d41d4454bf80c
En el caso de que el dispositivo no está en la lista, ejecute los siguientes comandos para reiniciar el servidor
ADB:
adb kill-servidor
adb start-servidor
Si el equipo aún no está en la lista, intente ejecutar el siguiente comando:
adb actualización de Android
Tenga en cuenta que también puede ser necesario reiniciar el sistema.
Prueba de la conexión adb

Suponiendo que la configuración adb ha tenido éxito en su plataforma de desarrollo elegido, el siguiente paso es
tratar de ejecutar la aplicación de prueba creada en el capítulo titulado Creación de una aplicación para Android
Ejemplo en Android Studio en el dispositivo.
Lanzamiento Android Studio, abra el proyecto AndroidSample y, una vez que el proyecto se haya cargado, haga
clic en el botón de ejecución se encuentra en la barra de herramientas Android Studio (Figura 6-10).
Figura 6-10
Suponiendo que el proyecto no ha sido previamente configurado para ejecutarse automáticamente en un

entorno emulador, el cuadro de diálogo Seleccionar dispositivo aparecerá con el dispositivo Android conectado
aparece como un dispositivo que está ejecutando. Figura 6-11, por ejemplo, enumera un dispositivo Nexus 7
como una diana adecuada para la instalación y la ejecución de la aplicación.
Figura 6-11
Para hacer esto, el dispositivo predeterminado para las pruebas, que el uso mismo dispositivo para la futura
opción de lanza. Con el dispositivo seleccionado, haga clic en el botón Aceptar para instalar y ejecutar la
aplicación en el dispositivo. Al igual que con el medio ambiente emulador, salida de diagnóstico en relación con
la instalación y puesta en marcha de la aplicación en el dispositivo se registra en la ventana de herramientas
Ejecutar.
Resumen
Mientras el Android emulador de dispositivo virtual proporciona un entorno de prueba excelente, es importante
tener en cuenta que no existe un sustituto real para asegurarse de que los funciones de una aplicación
correctamente en un dispositivo Android física. Esto, después de todo, es donde la aplicación se utiliza en el
mundo real.
Por defecto, sin embargo, el entorno Android estudio no está configurado para detectar los dispositivos Android
como un dispositivo de pruebas de destino. Es necesario, por lo tanto, para llevar a cabo algunas medidas con
el fin de ser capaz de cargar aplicaciones directamente en un dispositivo Android desde el entorno de desarrollo
de Android Studio. Los pasos exactos para lograr este objetivo difiere dependiendo de la plataforma de
desarrollo que se utiliza. En este capítulo, hemos cubierto los pasos para Linux, Mac OS X y Windows
plataformas basadas.
6 Los fundamentos de la Android Studio Editor Código
Desarrollo de aplicaciones para Android implica una cantidad considerable de trabajo de programación que, por
definición, implica escribir a máquina, revisión y modificación de líneas de código. No debería ser ninguna
sorpresa que la mayoría del tiempo de un programador dedicado al uso de Android Studio suelen implicar la
edición de código dentro de la ventana del editor.
El editor de código moderno tiene que ir mucho más allá de los fundamentos originales de escribir, borrar, cortar
y pegar. Hoy en día la utilidad de un editor de código se mide generalmente por factores tales como la cantidad
en que se reduce la tipificación requerida por el programador, la facilidad de la navegación a través de grandes
archivos de código fuente y la capacidad del editor para detectar y poner de relieve los errores de programación
en tiempo real, como se escribe el código. Como se pondrá de manifiesto en este capítulo, estas son sólo
algunas de las áreas en las que el editor de Android Estudio sobresale.
Aunque no es un panorama exhaustivo de las características del editor de Android de estudio, este capítulo
tiene como objetivo proporcionar una guía de las principales características de la herramienta. Los
programadores experimentados encontrarán que algunas de estas características son comunes a la mayoría de
los editores de código disponible en la actualidad, mientras que un número son exclusivas de este entorno de
edición especial.
Android Studio Editor

El editor de Android estudio aparece en el centro de la ventana principal cuando se selecciona una de Java,
XML u otro archivo de texto para su edición. Figura 7-1, por ejemplo, muestra una sesión típica editor con un
archivo de código fuente de Java cargado:
Figura 7-1
Los elementos que componen la ventana del editor se puede resumir de la siguiente manera:
A - Aquí el documento - Android Studio es capaz de contener múltiples archivos abiertos para la edición en un
momento dado. Como se abre cada archivo, se le asigna una ficha de documento que muestra el nombre del
archivo en la barra de pestañas situado a lo largo del borde superior de la ventana del editor.Un pequeño menú
desplegable aparecerá en la esquina derecha de la barra de pestañas cuando no hay suficiente espacio para
mostrar todas las fichas. Al hacer clic en este menú se desplegará una lista de archivos abiertos
adicionales. Una línea roja ondulada debajo de un nombre de archivo en una pestaña indica que el código en el
archivo contiene uno o más errores que deben ser abordados antes de que el proyecto se puede compilar y
ejecutar.
Cambio entre archivos es simplemente una cuestión de hacer clic en la ficha correspondiente o utilizando los
atajos de teclado Alt-Derecha-Izquierda y Alt. La navegación entre archivos también se puede realizar utilizando
el mecanismo Switcher (accesible a través de la combinación de teclas Ctrl-Tab).
Para desmontar un panel de editor desde la ventana principal de Android Estudio para que aparezca en una
ventana independiente, haga clic en la ficha y arrastrarlo a un área en el escritorio fuera de la ventana
principal. Para volver al editor a la ventana principal, haga clic en la pestaña archivo en la ventana del editor
separado y arrastrar y soltarlo en la barra de pestañas editor original en la ventana principal.
B - The Gutter área Editor - El área de alcantarilla es utilizado por el editor para mostrar iconos y controles
informativos. Algunos elementos típicos, entre otros, que aparecen en esta área cuneta está depurando
marcadores de punto de interrupción, los controles de plegar y desplegar bloques de código, marcadores,
marcadores y cambiar los números de línea. Los números de línea están apagados por defecto, pero se pueden
activar haciendo clic derecho en la cuneta y seleccionando la opción de menú Mostrar números de línea.
C - La barra de estado - A pesar de la barra de estado es en realidad parte de la ventana principal, en
contraposición con el editor, contiene alguna información acerca de la sesión de edición activa. Esta información
incluye la posición actual del cursor en términos de líneas y caracteres y el formato de codificación del archivo
(UTF-8, ASCII, etc.). Al hacer clic en estos valores en la barra de estado permite el ajuste correspondiente a
cambiar. Al hacer clic en el número de línea, por ejemplo, muestra el pase a la línea de diálogo.
D - El área Editor - Esta es el área principal donde se muestra el código, entró y editado por el usuario. Las
secciones posteriores de este capítulo cubrirán las principales características de la zona de edición en detalle.
E - La validación y Marker Sidebar - Android estudio incorpora una función denominada "análisis de código
sobre la marcha". Lo que esto significa básicamente es que a medida que está escribiendo código, el editor está
analizando el código para comprobar si hay advertencias y errores de sintaxis. El cuadrado de color en la parte
superior de la barra lateral de validación cambia de color de verde (no hay advertencias o errores detectados) a
amarillo (advertencias detectados) y roja (se han detectado errores). Al hacer clic en esta plaza se mostrará una
ventana emergente que contiene un resumen de los problemas encontrados con el código en el editor como se
ilustra en la Figura 7-2:
Figura 7-2
La barra lateral también muestra los marcadores en los lugares donde los problemas se han detectado
utilizando el mismo código de colores. Al pasar el puntero del ratón sobre una marca, cuando la línea de código
es visible en el área de edición se mostrará una ventana emergente que contiene una descripción del problema
(Figura 7-3):
Figura 7-3
Al pasar el puntero del ratón sobre una marca para una línea de código que se desplaza actualmente fuera del
área de visualización del editor mostrará un overlay "lente" que contiene el bloque de código en el que se
encuentra el problema (Figura 7-4) que le permite ser visto sin la necesidad de desplazarse a la ubicación en el
editor:
Figura 7-4
También vale la pena señalar que la plantilla del objetivo no se limita a las advertencias y errores en la barra
lateral. Al pasar el ratón sobre cualquier parte de la barra lateral se traducirá en una lente que aparece con el
código presente en ese lugar en el archivo de origen.
Después de haber proporcionado una visión general de los elementos que componen el editor de Android
Studio, el resto de este capítulo explorará las características clave del entorno de edición con más detalle.
La división de la ventana del editor

Por defecto, el editor mostrará un único panel que muestra el contenido del archivo seleccionado. Una
característica particularmente útil cuando se trabaja simultáneamente con múltiples archivos de código fuente es
la capacidad de dividir el editor en varios paneles. Para dividir el editor, haga clic en una pestaña archivo dentro
de la ventana del editor y seleccione la dividida verticalmente u opción de menú Dividir horizontalmente. Figura
7-5, por ejemplo, muestra el divisor en acción con la división editor en tres paneles:
Figura 7-5
La orientación de un panel de división se puede cambiar en cualquier momento haciendo clic derecho sobre la
pestaña correspondiente y seleccionando la opción de menú Orientación Cambio Splitter. Repita estos pasos
para cancelar la división de un solo panel, esta vez seleccionando la opción Unir la del menú.Todos los paneles
de división se puede eliminar con un clic derecho en cualquier pestaña y seleccionando la opción de menú Unir
la All.
Ventana división se puede utilizar para mostrar diferentes archivos, o para proveer varias ventanas en el mismo
archivo, lo que permite diferentes áreas del mismo archivo para ser vistos y editados simultáneamente.
Código de finalización
El editor de Android Studio tiene una cantidad considerable de conocimiento incorporado en la sintaxis de
programación Java y las clases y métodos que componen el SDK de Android, así como el conocimiento de su
propia base de código. Como se escribe código, el editor analiza lo que se ha escrito y, en su caso, se hacen
sugerencias con respecto a lo que podría ser necesario para completar una declaración o de referencia. Cuando
una sugerencia conclusión es detectado por el editor, aparecerá un panel que contiene una lista de
sugerencias. En la Figura 7-6, por ejemplo, el editor está sugiriendo posibilidades para el inicio de una
declaración de la secuencia:
Figura 7-6
Si ninguna de las sugerencias de terminación automática son correctas, simplemente siga escribiendo y el editor
seguirá perfeccionando las sugerencias en su caso. Para aceptar la sugerencia más arriba, basta con pulsar la
tecla Intro o Tab en el teclado. Para seleccionar una sugerencia diferente, utilice las flechas para moverse hacia
arriba y abajo en la lista, una vez más el uso de la Confirmar o la tecla Tab para seleccionar el elemento
resaltado.
Sugerencias de terminación pueden ser invocadas manualmente utilizando la secuencia de teclas Ctrl-
Espacio. Esto puede ser útil cuando se cambia una palabra o declaración en el editor. Cuando el cursor se
encuentra sobre una palabra en el editor, esa palabra resaltará automáticamente. Al pulsar Ctrl-Espacio
mostrará una lista de sugerencias alternativas. Para reemplazar la palabra actual con el elemento resaltado en
la lista de sugerencias, simplemente pulse la tecla Tab.
Además de la función de autocompletado en tiempo real, el editor de Android Studio también ofrece un sistema
denominado inteligente Finalización.Terminación inteligente se invoca utilizando la secuencia de teclas Shift +
Ctrl + Espacio y, si está activa, proporcionará sugerencias más detalladas basadas en el contexto actual del
código. Al pulsar la secuencia de atajo Shift-Ctrl-Espacio segunda vez proporcionará más sugerencias de una
gama más amplia de posibilidades.
Finalización de código puede ser una cuestión de preferencia personal por muchos programadores. En
reconocimiento de este hecho, Android Studio proporciona un alto nivel de control sobre la configuración de
terminación automática. Estos se pueden ver y modificar seleccionando Archivo -> Configuración ... opción de
menú y eligiendo Editor -> Código de finalización de la sección Configuración IDE del panel de configuración,
como se muestra en la Figura 7-7:
Figura 7-7
Finalización de instrucciones
Otra forma de realización automática proporcionada por el editor de Android Studio es la finalización de
instrucciones. Esto puede ser usado para llenar automáticamente los paréntesis y los apoyos para los artículos
tales como los métodos y las declaraciones de bucle. Finalización de instrucciones se invoca utilizando el Shift-
Ctrl-Enter (Shift-Cmd-Intro en Mac OS X) secuencia de teclas. Considere por ejemplo el siguiente código:
protegida myMethod void ()
Después de haber escrito este código en el editor, lo que provocó la finalización de instrucciones hará que el
editor para agregar automáticamente los frenos para el método:
protegida myMethod void () {
Información de parámetros
También es posible pedir al editor para proporcionar información sobre los parámetros de argumentos
aceptados por un método. Con el cursor colocado entre los soportes de una llamada a un método, el Ctrl-P
(Cmd-P en Mac OS X) secuencia de teclado mostrará los parámetros conocidos para ser aceptado por ese
método, con la sugerencia más probable resaltado en negrita:
Figura 7-8
Generación de código
Además de completar código tal como se escribe el editor puede, bajo ciertas condiciones, también generar el
código para usted. La lista de opciones de generación de código disponibles se muestra en la Figura 7-10 se
puede acceder mediante el Alt-Insert atajo de teclado cuando el cursor se encuentra en la ubicación en el
archivo en el que el código se va a generar.
Figura 7-9
A los efectos de un ejemplo, considere una situación en la que queremos ser notificados cuando una actividad
en nuestro proyecto está a punto de ser destruido por el sistema operativo. Como se describe en un capítulo
posterior de este libro, esto se puede lograr mediante la sustitución del método del ciclo de vida OnStop () de la
superclase Actividad. Para tener Android Estudio generar un método talón para esto, sólo tiene que seleccionar
los métodos de reemplazo ... opción de la lista de generación de código y seleccione el método OnStop () de la
lista resultante de los métodos disponibles:
Figura 7-10
Una vez seleccionado el método para sustituir, al hacer clic en Aceptar generará el método talón en la posición
actual del cursor en el archivo fuente de Java de la siguiente manera:
@ Override
protegida OnStop void () {
super.onStop ();
}
Plegable Código
Una vez que un archivo de código fuente alcanza cierto tamaño, incluso el código más cuidadosamente
formateado y bien organizada puede llegar a ser abrumadora y difícil de navegar. Android Estudio considera que
no siempre es necesario contar con el contenido de cada bloque de código visible en todo momento. Código de
navegación puede ser más fácil con el uso de la función de plegado de código del editor de Android
Studio. Plegado de código se controla el uso de marcadores que aparecen en la cuneta editor al principio y al
final de cada bloque de código en un archivo de origen. Figura 7-11, por ejemplo, pone de relieve los
marcadores de inicio y fin de una declaración de método que no se dobla en la actualidad:
Figura 7-11
Al hacer clic en cualquiera de estos marcadores se pliegue la declaración de tal manera que sólo la línea de la
firma es visible como se muestra en la Figura 7-12:
Figura 7-12
Para desplegar una sección colapsado de código, simplemente haga clic en el marcador de "+" en la cuneta
editor. Para ver el código oculto sin desdoblarla, pase el puntero del ratón sobre el "{...}" indicador como se
muestra en la Figura 7-13. El editor mostrará entonces la superposición de lentes que contiene el bloque de
código plegada:
Figura 7-13
Todos los bloques de código en un archivo puede doblarse o desplegarse utilizando las secuencias de teclado
Ctrl-Shift-Plus y Ctrl-Shift-Minus.
Por defecto, el editor de Android Studio automáticamente doblar algún código cuando se abre un archivo de
origen. Para configurar las condiciones en que esto sucede, seleccione Archivo -> Configuración ... y seleccione
el Editor -> entrada plegado de código que aparece en Configuración de IDE en el panel de configuración
resultante (Figura 7-14):
Figura 7-14
Búsqueda de Documentación Rápida
Contexto Java sensible y documentación Android se puede acceder al poner el cursor sobre la declaración para
la que se requiere documentación y pulsando la combinación de teclas Ctrl-Q (Ctrl-J en Mac OS X). Esto
mostrará una ventana emergente que contiene la documentación de referencia pertinente para el artículo. Figura
7-15, por ejemplo, muestra la documentación de la clase Menu Android.
Figura 7-15
Una vez que aparece, el emergente documentación se puede mover por la pantalla según sea necesario. Al
hacer clic en el icono de alfiler situado en la esquina derecha de la barra de título emergente se asegurará de
que la ventana emergente permanece visible una vez que el foco se mueve de nuevo al editor, dejando la
documentación visible como una referencia al escribir código.
Código El cambio de formato

En general, el editor de Android Studio formatear automáticamente el código en términos de sangrado,
espaciado y anidación de las declaraciones y los bloques de código a medida que se agregan. En situaciones
en las líneas de código necesitan ser reformateado (una ocurrencia común, por ejemplo, al cortar y pegar código
de ejemplo de un sitio web), el editor proporciona un código de origen de elemento reformateo que, cuando se
selecciona, se vuelva a formatear automáticamente el código para que coincida con la prevaleciente estilo de
código.
Para cambiar el formato de código fuente, pulse la secuencia de combinación de teclas Ctrl-Alt-L para mostrar el
cuadro de diálogo Código de reformateo (Figura 7-16). Este cuadro de diálogo ofrece la opción de cambiar el
formato de sólo el código seleccionado en ese momento, el archivo de origen toda actualmente activo en el
editor o todos los archivos en una carpeta de proyecto dado.
Figura 7-16
La gama completa de las preferencias de estilo de código se puede cambiar desde dentro del diálogo de
configuración del proyecto. Seleccione Archivo -> Configuración de opciones de menú y elija Estilo Código
enumerados en Configuración del proyecto en el panel de la izquierda para acceder a una lista de lenguajes de
programación y de marcas compatibles. Selección de un idioma proporcionará acceso a una amplia gama de
opciones de estilo de formato, todos los cuales pueden ser modificados desde el valor predeterminado de
Android Studio para que coincida con su estilo de código preferido.
Resumen
El editor de Android Estudio va a la gran longitud para reducir la cantidad de escritura necesaria para escribir
código y hacer que el código más fácil de leer y navegar. En este capítulo hemos cubierto algunas de las
características del editor clave, incluyendo la finalización de código, generación de código, editor de ventanas
división, plegado de código, formatear y búsqueda de documentación.
7 Una visión general de la arquitectura de Android (Android

Studio)
Hasta ahora, en este libro, se han tomado medidas para establecer un entorno adecuado para el desarrollo de
aplicaciones Android que utilizan Android Studio.Un paso inicial también se ha tenido en el proceso de
desarrollo de aplicaciones a través de la creación de un proyecto de aplicación de Android Estudio simple.
Antes de ahondar aún más en las cuestiones prácticas de desarrollo de aplicaciones de Android, sin embargo,
es importante obtener una comprensión de algunos de los conceptos más abstractos, tanto del SDK de Android
y el desarrollo de Android en general. Para una comprensión clara de estos conceptos ahora proporcionará una
base sólida sobre la que construir nuevos conocimientos. Comenzando con una visión general de la arquitectura
de Android en este capítulo, y continuando en los próximos capítulos de este libro, el objetivo es proporcionar
una visión detallada de los fundamentos del desarrollo de Android.
Android Software Stack

Android está estructurado en forma de una pila de software que comprende aplicaciones, un sistema operativo,
entorno de ejecución, middleware, servicios y bibliotecas. Esta arquitectura puede, tal vez, mejor ser
representado visualmente como se indica en la Figura 8-1. Cada capa de la pila, y los elementos
correspondientes dentro de cada capa, son altamente integrado y cuidadosamente afinado para proporcionar el
desarrollo óptimo de las aplicaciones y entorno de ejecución para dispositivos móviles.
Figura 8-1
El resto de este capítulo se trabajará a través de las diferentes capas de la pila de Android, comenzando en la
parte inferior con el Kernel de Linux.
El kernel de Linux
Situado en la parte inferior de la pila de software Android, el núcleo de Linux proporciona un nivel de abstracción
entre el hardware del dispositivo y las capas superiores de la pila de software Android. Basado en Linux versión
2.6, el kernel proporciona multitarea preventiva, servicios del sistema base de bajo nivel, tales como la memoria,
los procesos y la administración de energía, además de proporcionar una pila y dispositivos de red
controladores para hardware, como la pantalla del dispositivo, Wi-Fi y audio.
El núcleo original de Linux fue desarrollado en 1991 por Linus Torvalds y se combinó con un conjunto de
herramientas, utilidades y compiladores desarrollados por Richard Stallman en la Free Software Foundation
para crear un sistema operativo completo denominado GNU / Linux. Varias distribuciones de Linux se han
derivado de estos fundamentos básicos como Ubuntu y Red Hat Enterprise Linux.
Es importante señalar, sin embargo, que Android sólo utiliza el kernel de Linux. Dicho esto, vale la pena señalar
que el núcleo Linux fue desarrollado originalmente para su uso en los ordenadores tradicionales en forma de
equipos de sobremesa y servidores. De hecho, Linux está ahora más ampliamente desplegada en entornos de
servidores empresariales de misión crítica. Es un testimonio tanto a la potencia de los dispositivos móviles de
hoy en día y la eficiencia y el rendimiento del kernel de Linux que se encuentra este software en el corazón de la
pila de software Android.
Runtime Android - Dalvik Virtual Machine

Como se señaló anteriormente, el núcleo de Linux proporciona un entorno de ejecución multitarea que permite
que varios procesos se ejecuten al mismo tiempo. Sería fácil suponer, por tanto, que cada aplicación Android
simplemente ejecuta como un proceso directamente en el kernel de Linux. De hecho, cada aplicación que se
ejecuta en un dispositivo Android lo hace dentro de su propia instancia de la máquina virtual Dalvik (VM).
La ejecución de aplicaciones en máquinas virtuales proporciona una serie de ventajas. En primer lugar, las
aplicaciones son esencialmente sandboxed, en que no pueden interferir negativamente (intencionadamente o
no) con el sistema operativo u otras aplicaciones, ni pueden acceder directamente al hardware del
dispositivo. En segundo lugar, este nivel de abstracción forzada hace que la plataforma de aplicaciones neutral
en cuanto a que nunca están atados a ningún hardware específico.
La máquina virtual Dalvik fue desarrollado por Google y se basa en el kernel de Linux subyacente para la
funcionalidad de bajo nivel. Es más eficiente que el estándar Java VM en términos de uso de la memoria, y
específicamente diseñado para permitir varias instancias que se ejecuten de manera eficiente dentro de las
limitaciones de recursos de un dispositivo móvil.
Para ejecutar dentro de una máquina virtual Dalvik, código de la aplicación debe ser transformada a partir de
archivos estándar de clase Java para el ejecutable Dalvik formato (.dex), que tiene una huella de memoria 50%
más pequeño que el bytecode de Java estándar. Archivos de clase estándar de Java pueden normalmente
(aunque no siempre) se convertirán al formato Dex con la función dx incluye con el SDK de Android.
Runtime Android - Bibliotecas Core
Las Bibliotecas Android Core (también conocidas como las Bibliotecas Dalvik) se dividen en tres categorías
principales, cada uno de los cuales merece una descripción individual:
Dalvik VM Bibliotecas específicas

Este es un conjunto de librerías utilizadas predominantemente para interactuar directamente con una instancia
de la máquina virtual Dalvik y es poco probable que sea utilizado por la mayoría de los desarrolladores de
aplicaciones para Android.
Java interoperabilidad Bibliotecas

Aplicaciones Android se desarrollan predominantemente utilizando el lenguaje de programación Java. El entorno
de desarrollo estándar de Java incluye una amplia gama de clases que están contenidos en las bibliotecas de
tiempo de ejecución Java básicos. Estas bibliotecas proporcionan apoyo para tareas tales como manejo de
cadenas, redes y manipulación de archivos (por nombrar algunos) y son a la vez familiar y ampliamente utilizado
por los desarrolladores de Java, independientemente de la plataforma.
Los Java interoperabilidad Las bibliotecas son una implementación de código abierto (basado en el proyecto
Apache Harmony) de un subconjunto de las bibliotecas del núcleo estándar de Java que han sido adaptados y
transformados para su uso por aplicaciones que se ejecutan dentro de una máquina virtual Dalvik.
Bibliotecas Android
Esta categoría abarca aquellas bibliotecas basadas en Java que son específicos para el desarrollo de
Android. Los ejemplos de las bibliotecas en esta categoría incluyen las bibliotecas marco de aplicación, además
de los que facilitan la creación de interfaz de usuario, el dibujo de gráficos y el acceso de base de datos.
Un resumen de algunas bibliotecas Android núcleo tecla disponible para el programador Android es el siguiente:
 android.app - Proporciona acceso al modelo de solicitud y es la piedra angular de todas las

aplicaciones de Android.
 android.content - Facilita el acceso al contenido, la edición y la mensajería entre aplicaciones y
componentes de aplicaciones.
 android.database - Se utiliza para acceder a los datos publicados por los proveedores de contenidos
e incluye clases de manejo de base de datos SQLite.
 android.graphics - Un dibujo de la API de gráficos 2D de bajo nivel incluyendo colores, puntos, filtros,
rectángulos y lienzos.
 android.hardware - Presenta una API que proporciona el acceso al hardware, como el acelerómetro y
sensor de luz.
 android.opengl - Una interfaz de Java para los gráficos OpenGL ES 3D renderizado API.
 android.os - Proporciona aplicaciones con acceso a los servicios estándar del sistema operativo
incluyendo mensajes, servicios del sistema y la comunicación entre procesos.
 android.media - Proporciona clases para permitir la reproducción de audio y vídeo.
 android.net - Un conjunto de APIs que dan acceso a la pila de red. Incluye android.net.wifi, que
proporciona acceso a la pila inalámbrica del dispositivo.
 android.print - Incluye un conjunto de clases que permite que el contenido que se enviará a las
impresoras configuradas a partir de aplicaciones de Android.
 android.provider - Un conjunto de clases de conveniencia que ofrecen acceso a bases de datos
estándar de proveedores de contenido de Android, como los mantenidos por las aplicaciones de calendario
y contactos.
 android.text - Se utiliza para representar y manipular texto en una pantalla del dispositivo.
 android.util - Un conjunto de clases de utilidad para las tareas como la cadena y la conversión de
número, manejo de XML y la fecha y la manipulación del tiempo.
 android.view - Los bloques fundamentales de las interfaces de usuario de aplicaciones de
construcción.
 android.widget - Una rica colección de componentes de interfaz de usuario pre-construidos, tales
como botones, etiquetas, las vistas de lista, los administradores de diseño, botones de radio, etc.
 android.webkit - Un conjunto de clases destinadas a permitir que las capacidades de navegación web
que se construirán en las aplicaciones.
Después de haber cubierto las bibliotecas del núcleo basadas en Java en el tiempo de ejecución de Android,
ahora es el momento de centrar nuestra atención en la C / C ++ bibliotecas basadas contenidas en esta capa de
la pila de software Android.
C / C ++ Bibliotecas
Las bibliotecas del núcleo de ejecución Android descritos en la sección anterior son basadas en Java y
proporcionan las API primaria para los desarrolladores que escriben aplicaciones de Android. Es importante
señalar, sin embargo, que las bibliotecas del núcleo en realidad no realizan gran parte del trabajo real y están,
de hecho, esencialmente "envoltorios" de Java en torno a un conjunto de C / C ++ bibliotecas basados. Al
realizar llamadas, por ejemplo, a la biblioteca android.opengl para dibujar gráficos en 3D en la pantalla del
dispositivo, la biblioteca realidad última instancia, hace llamadas a la biblioteca de la OpenGL ES C ++, que, a
su vez, funciona con el kernel Linux subyacente para realizar las tareas de dibujo . C / C bibliotecas ++ se
incluyen para cumplir con una amplia y diversa gama de funciones, incluyendo 2D y dibujo de gráficos 3D,
Secure Sockets Layer (SSL), gestión de base de datos SQLite, reproducción de audio y vídeo, mapa de bits y
vectores renderización de fuentes, subsistema de visualización y capa gráfica gestión y una implementación de
la biblioteca del sistema estándar de C (libc).
En la práctica, el desarrollador típica aplicación Android accederá a estas bibliotecas únicamente a través de las
API de bibliotecas centrales Android basados en Java. En el caso de que se necesita acceso directo a estas
bibliotecas, esto se puede lograr utilizando el Kit de Android Desarrollo nativo (NDK), cuyo propósito es llamar a
los métodos nativos de lenguajes de programación no Java (tales como C y C ++) de en el código Java
utilizando Java Native Interface (JNI).
Application Framework
El Application Framework es un conjunto de servicios que forman colectivamente el entorno en el que las
aplicaciones de Android se ejecutan y se gestionan.Este marco implementa el concepto de que las aplicaciones
de Android se construyen a partir de componentes reutilizables, intercambiables y reemplazables.Este concepto
se toma un paso más en una aplicación que también es capaz de publicar sus capacidades junto con los datos
correspondientes de modo que se pueden encontrar y reutilizados por otras aplicaciones.
El marco Android incluye los siguientes servicios principales:
 Activity Manager - Controla todos los aspectos del ciclo de vida de la aplicación y pila actividad.
 Proveedores de Contenido - Permite que las aplicaciones para publicar y compartir datos con otras
aplicaciones.
 Resource Manager - Proporciona acceso a los recursos no código incrustado como cuerdas, ajustes
de color y diseños de interfaz de usuario.
 Notificaciones Gerente - Permite a las aplicaciones para mostrar alertas y notificaciones para el
usuario.
 Vista System - Un conjunto ampliable de puntos de vista que se utilizan para crear interfaces de
usuario de aplicaciones.
 Gestor de Paquetes - El sistema por el cual las aplicaciones son capaces de buscar información
acerca de otras aplicaciones instaladas actualmente en el dispositivo.
 Telefonía Gerente - Proporciona información a la aplicación de los servicios telelphony disponibles en
el dispositivo, tales como información de estado y abonado.
 Location Manager - Proporciona acceso a los servicios de localización que permiten una aplicación
para recibir actualizaciones sobre los cambios de ubicación.
Aplicaciones
Situado en la parte superior de la pila de software Android son las aplicaciones. Estos comprenden tanto las
aplicaciones nativas proporcionadas con la aplicación Android en particular (por ejemplo, las aplicaciones de
navegador web y correo electrónico) y las aplicaciones de terceros instaladas por el usuario después de la
compra del dispositivo.
Resumen
Una buena base de conocimientos de desarrollo de Android requiere una comprensión de la estructura general
de Android. Android se implementa en forma de una arquitectura de pila de software que consiste en un núcleo
de Linux, un entorno de ejecución y las bibliotecas correspondientes, un marco de aplicación y un conjunto de
aplicaciones. Las aplicaciones están escritas principalmente en Java y se ejecutan dentro de instancias
individuales de la máquina virtual Dalvik. Los objetivos clave de la arquitectura de Android son el rendimiento y
la eficiencia, tanto en la ejecución de aplicaciones y en la ejecución de su reutilización en el diseño de
aplicaciones.
8 La Anatomía de una aplicación Android Android Estudio
Independientemente de sus experiencias de programación anteriores, ya sea Windows, Mac OS X, Linux o

incluso iOS basado, las posibilidades son buenas de que el desarrollo de Android es muy diferente a cualquier
cosa que hayas visto antes. El objetivo de este capítulo, por lo tanto, es proporcionar una comprensión de los
conceptos de alto nivel detrás de la arquitectura de aplicaciones de Android. Al hacer esto, vamos a explorar en
detalle tanto los diversos componentes que pueden ser utilizados para construir una aplicación y los
mecanismos que permiten a éstos a trabajar juntos para crear una aplicación coherente.
Actividades Android
Quienes están familiarizados con los lenguajes de programación orientados a objetos como Java, C ++ o C #
estarán familiarizados con el concepto de elementos de funcionalidad de la aplicación en las clases que luego
son instanciados como objetos y manipuladas para crear una aplicación que encapsula.Dado que las
aplicaciones de Android están escritos en Java, esto sigue siendo mucho el caso. Android, sin embargo,
también lleva el concepto de componentes reutilizables a un nivel superior.
Aplicaciones de Android son creados por reunir uno o más componentes conocidos como Actividades. Una
actividad es un único módulo, independiente de la funcionalidad de la aplicación que normalmente se
correlaciona directamente con una única pantalla de interfaz de usuario y su funcionalidad correspondiente.Una
aplicación citas podría, por ejemplo, tener una pantalla de actividad que muestra las citas establecidas para el
día actual. La aplicación también puede utilizar una segunda actividad que consiste en una pantalla donde las
nuevas citas pueden ser introducidos por el usuario.
Las actividades están destinadas como bloques completamente reutilizables e intercambiables de construcción
que pueden ser compartidos entre diferentes aplicaciones. Una aplicación de correo electrónico existente, por
ejemplo, podría contener una actividad específicamente para redactar y enviar un mensaje de correo
electrónico. Un desarrollador podría estar escribiendo una aplicación que también tiene la obligación de enviar
un mensaje de correo electrónico. En lugar de desarrollar una actividad de la composición de correo electrónico
específicamente para la nueva aplicación, el desarrollador puede simplemente utilizar la actividad de la
aplicación de correo electrónico existente.
Las actividades se crean como subclases de la clase Actividad Android y deben implementarse de manera que
sea totalmente independiente de otras actividades en la aplicación. En otras palabras, una actividad compartida
no puede confiar en ser llamado en un punto conocido en un flujo de programa (ya que otras aplicaciones
pueden hacer uso de la actividad de manera imprevista) y una actividad no puede llamar directamente métodos
o datos de la instancia de acceso de otra actividad. Esto, en cambio, se consigue utilizando los Fines y
proveedores de contenido.
Por defecto, una actividad no puede devolver resultados a la actividad de la que se invoca. Si se requiere esta
función, la actividad debe iniciarse específicamente como un sub-actividad de la actividad de origen.
Intenciones Android
Intenciones son el mecanismo por el que una actividad es capaz de lanzar otro y poner en práctica el flujo a
través de las actividades que componen una aplicación. Intenciones consisten en una descripción de la
operación a realizar y, opcionalmente, los datos sobre los que se va a realizar.
Intenciones puede ser explícita, en que solicitan la puesta en marcha de una actividad específica haciendo
referencia a la actividad por nombre de la clase, o implícito por el que se establezca el tipo de acción a realizar o
el suministro de datos de un tipo específico en el que la acción se va a realizar . En el caso de las intenciones
implícitas, el tiempo de ejecución Android seleccionará la actividad para lanzar que más se ajuste a los criterios
especificados por la Intención mediante un proceso conocido como la Resolución Intención.
Broadcast Intenciones
Otro tipo de intención, la intención de difusión, es una amplia intención sistema que se envía a todas las
aplicaciones que se han registrado un receptor de radiodifusión "interesado". El sistema Android, por ejemplo,
suelen enviará Broadcast Intenciones para indicar cambios en el estado del dispositivo, tales como la realización
de inicio del sistema, la conexión de una fuente de alimentación externa al dispositivo o la pantalla que se está
encendido o apagado.
A Intención de emisión puede ser normal (asíncrono) en que se envía a todos los receptores de radiodifusión
interesadas en más o menos al mismo tiempo, o ordenó en que se envía a un receptor en un momento en el
que se puede procesar y luego o bien abortado o permitido que pasar a la siguiente Receptor Broadcast.
Receptores de radiodifusión
Receptores de radiodifusión son el mecanismo por el cual las aplicaciones son capaces de responder a
Broadcast Intenciones. Un receptor de radiodifusión debe ser registrado por una aplicación y configurado con un
filtro de Intención para indicar los tipos de emisión en la que esté interesado. Cuando se emite una intención
coincidente, el receptor será invocada por el tiempo de ejecución de Android, independientemente de si la
aplicación que ha registrado el receptor se está ejecutando actualmente. El receptor dispone de 5 segundos
para completar cualquier tarea que se le exigen (como el lanzamiento de un servicio, por lo que las
actualizaciones de datos o emitir una notificación al usuario) antes de regresar. Receptores de radiodifusión
funcionar en segundo plano y no tienen una interfaz de usuario.
Servicios para Android

Servicios de Android son procesos que se ejecutan en segundo plano y que no tienen una interfaz de
usuario. Ellos se pueden iniciar y posteriormente gestionar desde las actividades, los receptores de radiodifusión
u otros servicios. Servicios para Android son ideales para situaciones en las que una aplicación necesita para
continuar la realización de tareas, pero no necesariamente necesitan una interfaz de usuario para que sea
visible para el usuario.Aunque los Servicios carecen de una interfaz de usuario, que todavía puede notificar al
usuario de eventos utilizando las notificaciones y tostadas (mensajes de notificación pequeñas que aparecen en
la pantalla sin interrumpir la actividad visible actualmente) y también son capaces de emitir Intenciones.
Los servicios se les da una mayor prioridad por el tiempo de ejecución de Android que muchos otros procesos y
sólo se terminarán como último recurso, por el sistema con el fin de liberar recursos. En el caso de que el tiempo
de ejecución necesita para matar a un servicio, sin embargo, que se reiniciará automáticamente tan pronto como
los recursos adecuados una vez estén disponibles. Un servicio puede reducir el riesgo de extinción por la que se
declara a sí mismo como tener que ejecutar en primer plano. Esto se consigue haciendo una llamada a
startForeground (). Esto sólo se recomienda para las situaciones en las que la terminación sería perjudicial para
la experiencia del usuario (por ejemplo, si el usuario está escuchando audio transmitidas por el Servicio).
Ejemplo situaciones en que un servicio puede ser una solución práctica incluyen, como se mencionó
anteriormente, la transmisión de audio que debe seguir cuando la aplicación ya no está activa, o una aplicación
de seguimiento del mercado de valores que hay que notificar al usuario cuando una parte realiza un precio
determinado .
Proveedores de Contenido
Proveedores de contenido implementar un mecanismo para el intercambio de datos entre
aplicaciones. Cualquier aplicación puede proporcionar otras aplicaciones con acceso a los datos subyacentes a
través de la implementación de un proveedor de contenidos que incluye la posibilidad de añadir, eliminar y
consultar los datos (sujeto a permisos). El acceso a los datos se realiza a través de un Universal Resource
Identifier (URI) definido por el proveedor de contenidos. Los datos pueden ser compartidos en forma de un
archivo o una base de datos completa de SQLite.
Las aplicaciones nativas de Android incluyen una serie de proveedores de contenido estándar que permite que
las aplicaciones accedan a los datos, como contactos y archivos multimedia.
Los proveedores de contenidos disponibles en la actualidad en un sistema Android se pueden localizar usando
una Resolver contenido.
El Manifiesto de la aplicación
El pegamento que reúne los diferentes elementos que componen una aplicación es el archivo de manifiesto de
aplicación. Es dentro de este archivo basado en XML que la aplicación se esbozan las actividades, servicios,
receptores de radiodifusión, proveedores de datos y los permisos que componen la solicitud completa.
De recursos de aplicaciones
Además del archivo de manifiesto y los archivos de Dex que contienen el código de bytes ejecutable de la
máquina virtual Dalvik, una aplicación para Android también contendrá típicamente una colección de archivos de
recursos. Estos archivos contienen recursos tales como las cadenas, imágenes, fuentes y colores que aparecen
en la interfaz de usuario junto con la representación XML de los diseños de interfaz de usuario. De forma
predeterminada, estos archivos se almacenan en el / res subdirectorio de la jerarquía de la aplicación del
proyecto.
Contexto de aplicación
Cuando se compila una aplicación, se crea una clase llamada R que contiene referencias a los recursos de la
aplicación. El archivo de manifiesto de aplicación y estos recursos se combinan para crear lo que se conoce
como el contexto de aplicación. Este contexto, representada por la clase Contexto Android, se puede utilizar en
el código de la aplicación para obtener acceso a los recursos de la aplicación en tiempo de ejecución. Además,
una amplia gama de métodos puede ser llamado en el contexto de una aplicación para recopilar información y
realizar cambios en el medio ambiente de la aplicación en tiempo de ejecución.
Resumen
Una serie de diferentes elementos se puede reunió con el fin de crear una aplicación Android. En este capítulo,
hemos proporcionado una visión general de alto nivel de las actividades, servicios, los intentos y los receptores
de radiodifusión, junto con un resumen de los recursos de archivos y aplicaciones de manifiesto. Máxima
reutilización y la interoperabilidad son promovidos a través de la creación de módulos individuales,
independientes de la funcionalidad en forma de actividades y las intenciones, mientras que el intercambio de
datos entre las aplicaciones se consigue mediante la aplicación de los proveedores de contenidos.
Mientras que las actividades se centran en las áreas donde el usuario interactúa con la aplicación (una actividad
que equivale esencialmente a una sola pantalla de interfaz de usuario), el proceso de fondo se maneja
normalmente por servicios y receptores de radiodifusión.
Los componentes que constituyen la aplicación se describen para el sistema de ejecución de Android en un
archivo de manifiesto que, junto con los recursos de la aplicación, representa el contexto de la aplicación.
Mucho se ha cubierto en este capítulo que es más probable nuevo para el desarrollador promedio. Tenga la
seguridad, sin embargo, que una amplia exploración y la utilización práctica de estos conceptos se harán en los
capítulos siguientes para garantizar una base de conocimientos sólida sobre la que construir sus propias
aplicaciones.
9 Entender Aplicación para Android y Actividad Lifecycles
(Android Studio)
En los capítulos anteriores hemos aprendido que las aplicaciones de Android se ejecutan dentro de los procesos
de la máquina virtual y que se componen de varios componentes en forma de actividades, servicios y receptores
de radiodifusión. El objetivo de este capítulo es ampliar este conocimiento observando el ciclo de vida de
aplicaciones y actividades dentro del sistema de ejecución de Android.
Independientemente de la fanfarria sobre la cantidad de memoria y potencia de cálculo reside en los dispositivos
móviles de hoy en día en comparación con los sistemas de escritorio de ayer, es importante tener en cuenta que
estos dispositivos todavía se consideran "recursos limitados" según las normas de la moderna sistemas de
escritorio y portátiles basados, sobre todo en términos de memoria. Como tal, una responsabilidad clave del
sistema Android es asegurar que estos recursos limitados se gestionan con eficacia y que tanto el sistema
operativo y las aplicaciones que se ejecutan en él siguen siendo sensibles al usuario en todo momento. Con el
fin de lograr esto, Android se da un control completo sobre el ciclo de vida y el estado tanto de los procesos en
los que se ejecutan las aplicaciones y los componentes individuales que comprenden esas aplicaciones.
Un factor importante en el desarrollo de aplicaciones para Android, por lo tanto, es para obtener una
comprensión tanto de los modelos de gestión del ciclo de vida de la aplicación y de la actividad de Android, y las
formas en que una aplicación puede reaccionar a los cambios de estado que es probable que se le ha impuesto
durante su curso de la vida ejecución.
Aplicaciones para Android y Gestión de Recursos

Las aplicaciones de Android, según lo establecido anteriormente, se ejecutan dentro de las instancias de la
máquina virtual Dalvik con cada máquina virtual que se está viendo por el sistema operativo como un proceso
independiente. Si el sistema detecta que los recursos del dispositivo están llegando a la capacidad que tomará
las medidas necesarias para poner fin a los procesos para liberar memoria.
Al hacer una determinación en cuanto a que el proceso de terminar con el fin de liberar memoria, el sistema
tiene en cuenta tanto la prioridad y el estado de todos los procesos que se están ejecutando, la combinación de
estos factores para crear lo que se conoce por Google como una jerarquía de importancia. Los procesos se
termina entonces comenzando con la prioridad más baja y trabajar en la jerarquía hasta que los recursos
suficientes han sido liberados para que el sistema funcione.
Estados Proceso Android

Procesos aplicaciones host y aplicaciones están formados por componentes. Dentro de un sistema Android, el
estado actual de un proceso se define por el componente activo de más alto rango dentro de la aplicación que
alberga. Como se indica en la Figura 10-1, un proceso puede estar en uno de los siguientes cinco estados en un
momento dado:
Figura 10-1
Proceso de primer plano

Estos procesos se les asigna el más alto nivel de prioridad. En cualquier momento, hay poco probable que sea
más de uno o dos procesos en primer plano activo y por lo general son los últimos en ser terminado por el
sistema. Un proceso debe cumplir con uno o más de los siguientes criterios para obtener el estatuto de primer
plano:
 Hosts una actividad con la que el usuario está interactuando.

 Hosts un servicio conectado a la actividad con la que el usuario está interactuando.
 Hosts un servicio que se ha indicado, a través de una llamada a startForeground (), que la terminación
sería perjudicial para la experiencia del usuario.
 Hosts un Servicio de ejecución sea su onCreate (), onResume () o onStart () devoluciones de llamada.
 Los anfitriones de un receptor de difusión que se está ejecutando actualmente su método OnReceive
().
Proceso Visible
Un proceso que contiene una actividad que es visible para el usuario, pero no es la actividad con la que el
usuario está interactuando se clasifica como un "proceso visible". Este es típicamente el caso cuando una
actividad en el proceso es visible para el usuario, pero otra actividad, tal como una pantalla parcial o de diálogo,
está en primer plano. Un proceso también es elegible para el estado visible si se aloja un servicio que es, en sí
mismo, unido a una actividad visible o en primer plano.
Proceso de Servicio
Los procesos que contienen un servicio que ya se ha iniciado y está ejecutando actualmente.
Proceso de fondo
Un proceso que contiene una o más actividades que actualmente no están visibles para el usuario, y no aloja un
servicio que califica para Servicio estado del proceso. Los procesos que entran en esta categoría se encuentran
en alto riesgo de extinción en caso de que la memoria adicional necesita ser liberado para procesos de prioridad
superior. Android mantiene una lista dinámica de los procesos de fondo, finalizar procesos en orden cronológico
de tal manera que los procesos que eran los menos recientemente en el primer plano se matan primero.
Proceso de vacío
Procesos vacíos ya no contienen todas las aplicaciones activas y se mantienen en la memoria el momento de
servir como anfitriones para las aplicaciones recién lanzados. Esto es algo análogo a mantener las puertas
abiertas y el motor en marcha en un autobús a la espera de los pasajeros que llegan. Dichos procesos son,
obviamente, considera la prioridad más baja y son los primeros en ser asesinados para liberar recursos.
Dependencias entre procesos

La situación con respecto a la determinación del proceso de prioridad más alta es un poco más compleja de lo
que se indica en el apartado anterior, por la sencilla razón de que los procesos a menudo pueden ser
interdependientes. Como tal, al hacer una determinación en cuanto a la prioridad de un proceso, el sistema
Android también tener en cuenta si el proceso es de alguna manera servir otro proceso de mayor prioridad (por
ejemplo, un proceso de servicio que actúa como el proveedor de contenido para una proceso en primer
plano). Como regla básica, la documentación Android establece que un proceso no puede ser clasificado más
bajo que otro proceso que actualmente está sirviendo.
El Ciclo de Vida de Actividad

Como hemos determinado anteriormente, el estado de un proceso de Android se determina en gran parte por el
estado de las actividades y componentes que forman la aplicación que alberga. Es importante entender, por lo
tanto, que estas actividades también la transición a través de diferentes estados durante la vida útil ejecución de
una aplicación. El estado actual de una actividad se determina, en parte, por su posición en algo que se llama la
Actividad Stack.
La Actividad Pila
Para cada aplicación que se ejecuta en un dispositivo Android, el sistema de ejecución mantiene una actividad
Stack. Cuando se inicia una aplicación, la primera de las actividades de la aplicación para iniciarse se coloca en
la pila. Cuando se inicia una segunda actividad, se coloca en la parte superior de la pila y la actividad anterior se
empuja hacia abajo. La actividad en la parte superior de la pila se conoce como el (o correr) actividad
activo. Cuando la actividad salidas activas, que se extrae de la pila por el tiempo de ejecución y la actividad
situada inmediatamente debajo de ella en la pila se convierte en la actividad activo actual. Podría, por ejemplo,
porque la tarea para la que es responsable se ha completado la actividad en la parte superior de la pila
simplemente salir.Alternativamente, el usuario puede haber seleccionado un botón "Atrás" en la pantalla para
volver a la actividad anterior, haciendo que la actividad actual para hacer estallar de la pila por el sistema de
ejecución y por lo tanto destruida. Una representación visual de la Android Actividad Stack se ilustra en la Figura
10-2:
Figura 10-2
Como se muestra en el diagrama, nuevas actividades son empujados a la parte superior de la pila cuando se
inician. La actividad activa actual se encuentra en la parte superior de la pila hasta que se empuja hacia abajo o
bien la pila por una nueva actividad, o se desprendió la pila cuando sale o el usuario navega a la actividad
anterior. En el caso de que los recursos se vuelven restringido, el tiempo de ejecución matará actividades,
empezando por los que están en la parte inferior de la pila.
La Actividad Stack es lo que se conoce en la terminología de programación como-In-First-Out Last (LIFO) pila
en que el último elemento que se inserta en la pila es el primero en hacer estallar apagado.
Actividad Unidos
Una actividad puede estar en uno de un número de diferentes estados durante el curso de su ejecución dentro
de una aplicación:
 Activo / Running - La actividad es en la parte superior de la Actividad Pila, es la tarea de primer plano
visible en la pantalla del dispositivo, tiene el foco y actualmente está interactuando con el usuario. Esta es
la actividad menos probable que se concluyan en caso de escasez de recursos.
 En pausa - La actividad es visible para el usuario, pero actualmente no tiene enfoque (normalmente
porque esta actividad está parcialmente oscurecida por la actividad activo corriente). Actividades en pausa
se mantienen en la memoria, permanecer unidos a el administrador de ventanas, conservar toda la
información de estado y rápidamente se puede restaurar al estado activo cuando se trasladó a la parte
superior de la Actividad Stack.
 Stopped - La actividad actualmente no es visible para el usuario (en otras palabras, está totalmente
oscurecido en la pantalla del dispositivo por otras actividades). Al igual que con las actividades en pausa,
se conserva toda la información de estado y miembro, pero está en mayor riesgo de extinción en
situaciones de poca memoria.
 Muerto - La actividad ha sido terminado por el sistema de ejecución con el fin de liberar memoria y ya
no está presente en la actividad Stack. Tales actividades deben reiniciarse si es requerido por la aplicación.
Los cambios de configuración
Hasta ahora, en este capítulo, hemos visto dos de las causas para el cambio de estado de una actividad
Android, es decir, el movimiento de una actividad entre el primer plano y el fondo, y la terminación de una
actividad por el sistema de ejecución con el fin de liberar la memoria. De hecho, hay un tercer escenario en el
que el estado de una actividad puede cambiar radicalmente y esto implica un cambio en la configuración del
dispositivo.
Por omisión, cualquier cambio en la configuración que afecta a la apariencia de una actividad (por ejemplo, la
rotación de la orientación del dispositivo entre el retrato y el paisaje, o cambiar una configuración de fuentes del
sistema) harán que la actividad sea destruido y recreado. El razonamiento detrás de esto es que los cambios
afecten a recursos tales como el diseño de la interfaz de usuario y simplemente destruir y volver a crear
actividades impactado es la forma más rápida para una actividad para responder a los cambios de
configuración.
Manipulación de cambio de estado

Si nada más, debe ser claro en este capítulo que una aplicación y, por definición, los componentes contenidos
en el mismo pasará a través de muchos estados durante el curso de su vida útil. De particular importancia es el
hecho de que se impongan estos cambios de estado (hasta e incluyendo la terminación completa) de la
aplicación por el tiempo de ejecución de Android sujetos a las acciones del usuario y la disponibilidad de
recursos en el dispositivo.
En la práctica, sin embargo, estos cambios de estado no son impuestas por completo sin previo aviso y una
solicitud serán, en la mayoría de circunstancias, serán notificados por el sistema de ejecución de los cambios y
se les da la oportunidad de reaccionar en consecuencia. Esto suele implicar el ahorro o la restauración de las
estructuras internas de datos y estado de la interfaz de usuario, lo que permite al usuario cambiar fácilmente
entre las aplicaciones y proporcionar al menos la aparición de múltiples, al mismo tiempo la ejecución de
aplicaciones. Los pasos a seguir en el manejo de gracia cambios de estado se tratarán en detalle en el próximo
capítulo titulado Manejo Android Actividad Cambios de estado.
Resumen
Los dispositivos móviles son típicamente considerados como recursos limitados, especialmente en términos de
capacidad de memoria interna. En consecuencia, la responsabilidad primordial del sistema operativo Android es
asegurar que las aplicaciones y el sistema operativo en general, siguen siendo sensibles al usuario. Las
solicitudes se reciben en Android dentro de los procesos (esencialmente las instancias de la máquina virtual
Dalvik). Cada aplicación, a su vez, se compone de los componentes en forma de actividades y servicios.
El sistema de ejecución Android tiene el poder de poner fin a los procesos y actividades individuales con el fin
de liberar memoria. Se toma el estado del proceso en consideración por el sistema de ejecución de la hora de
decidir si un proceso es un candidato adecuado para la terminación. El estado de un proceso depende en gran
medida del estado de las actividades organizadas por ese proceso.
El mensaje clave de este capítulo es que una aplicación se mueve a través de una variedad de estados durante
su vida útil ejecución y tiene muy poco control sobre su destino dentro del entorno de ejecución de
Android. Esos procesos y actividades que no están interactuando directamente con el usuario corren un mayor
riesgo de rescisión por parte del sistema de ejecución. Un elemento esencial del desarrollo de aplicaciones de
Android, por lo tanto, consiste en la capacidad de una aplicación para responder a las notificaciones de cambio
de estado desde el sistema operativo, un tema que se trata en el capítulo siguiente.
11 Manipulación Android Actividad Cambios de estado en

Android Estudio
Con base en la información que se indica en el capítulo titulado Comprensión Aplicación para Android y
Actividad Ciclos de vida ahora es evidente que las actividades que componen una aplicación pasan a través de
una variedad de diferentes estados durante el transcurso de la vida útil de la aplicación. El cambio de un estado
a otro es impuesta por el sistema de ejecución de Android y es, por tanto, en gran medida fuera del control de la
propia actividad. Dicho esto, en la mayoría de los casos el tiempo de ejecución ofrecerá la actividad en cuestión
con una notificación del cambio de estado inminente, dándole así tiempo para reaccionar en consecuencia. En
la mayoría de los casos, esto implicará ahorro o la restauración de los datos relativos al estado de la actividad y
su interfaz de usuario. El objetivo principal de este capítulo es proporcionar una visión general de alto nivel de
las formas en que una actividad pueda ser notificado de un cambio de estado y para delinear las áreas en las
que es aconsejable guardar o restaurar la información de estado. Después de haber cubierto esta información,
el capítulo y luego tocar brevemente el tema de la vida útil de actividad.
actividad de la clase
Con pocas excepciones, las actividades en una aplicación se crean como subclases de cualquiera de la clase
Actividad Android, o de otra clase que es, en sí, una subclase de la clase de actividad (por ejemplo, las clases
ActionBarActivity o FragmentActivity). Consideremos, por ejemplo, el proyecto AndroidSample sencillo creado
en Creación de una aplicación para Android Ejemplo en Android Studio. Cargar este proyecto en el entorno
Android Estudio y busque el archivo AndroidSampleActvity.java (ubicado en AndroidSample -> aplicación -> src
-> principal -> Java -> com.ebookfrenzy.androidsample). Después de haber localizado el archivo, haga doble clic
en él para cargarlo en el editor en el que se leerá como sigue:
com.ebookfrenzy.androidsample paquete;
android.support.v7.app.ActionBarActivity importación;
android.os.Bundle importación;
android.view.Menu importación;
android.view.MenuItem importación;
public class AndroidSampleActivity extiende ActionBarActivity {
@ Override
protected void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_android_sample);
}
@ Override
public boolean onCreateOptionsMenu (menú Menú) {
// Inflar el menú; esto agrega elementos a la barra de acción si está

presente.
. getMenuInflater () inflar (R.menu.android_sample, menú);
return true;
}
@ Override
public boolean onOptionsItemSelected (elemento MenuItem) {
// Elemento de la barra de acción Mango clic aquí. La barra de acción hará
// Manejar automáticamente los clics en el botón / Subir Inicio, siempre
// Como se especifica una actividad principal en AndroidManifest.xml.
int id = item.getItemId ();
si (id == R.id.action_settings) {
return true;
}
volver super.onOptionsItemSelected (punto);
}
}
Cuando se creó el proyecto, instruimos Android Studio también para crear una actividad inicial llamado
AndroidSampleActivity. Como es evidente por el código anterior, la clase AndroidSampleActivity se extiende, y
por lo tanto es una subclase de la clase ActionBarActivity.
Una revisión de la documentación de referencia para la clase ActionBarActivity revelaría que ella misma es una
subclase de la clase de actividad. Esto se puede verificar en el editor de Android Studio usando la ventana de
herramientas Jerarquía. Con el archivo AndroidSampleActivity.java cargado en el editor, haga clic en
ActionBarActivity en la línea de declaración de la clase pública y presionar la combinación de teclas Ctrl-H. La
ventana de herramientas jerarquía posteriormente aparecerá mostrando la jerarquía de clases de la clase
seleccionada. Como se ilustra en la Figura 11-1, ActionBarActivity está claramente una subclase de la clase
FragmentActivity que es en sí misma una subclase de la clase Actividad:
Figura 11-1
Esto plantea la pregunta de por qué se utiliza en lugar de la clase Actividad ActionBarActivity. La razón de esto
se remonta a las selecciones realizadas cuando el proyecto fue creado por primera vez. Al elegir los objetivos de
la versión SDK para el proyecto en el capítulo titulado Creación de una aplicación Android en Android Ejemplo
de estudio, el proyecto se ha configurado para llegar a un nivel mínimo de SDK API 8: Android 2.2. Desde la
introducción de Android 3.0, sin embargo, las aplicaciones han incluido una vista Barra de acciones en la parte
superior de la pantalla que proporciona opciones de menú y la información al usuario. El propósito de la clase
ActionBarActivity es hacer de esta Barra de acciones disponibles para las aplicaciones que se requieren para
funcionar en las versiones anteriores de Android y se incluye como parte de la biblioteca de soporte
android.support.v7. Si hubiéramos especificamos API 11: Android 3.0 o posterior como el SDK mínimo para el
proyecto AndroidSample, sin embargo, la actividad se habría declarado que no habría sido necesaria una
subclase de la clase de actividad en lugar de ActionBarActivity ya la compatibilidad hacia atrás para la Barra de
acciones.
La clase de actividad y sus subclases contienen una serie de métodos que están destinados a ser llamado por el
tiempo de ejecución de Android para notificar una actividad que su estado está cambiando. A los efectos de este
capítulo, nos referiremos a estos como los métodos de la actividad del ciclo de vida. Una clase de actividad
simplemente necesita reemplazar estos métodos e implementar la funcionalidad necesaria dentro de ellos con el
fin de reaccionar en consecuencia a los cambios de estado.
Uno de estos métodos es el nombre onCreate () y, volviéndose una vez más al fragmento de código anterior,
podemos ver que este método ya ha sido anulado y puesto en práctica por nosotros en la clase
AndroidSampleActivity. En una sección posterior exploraremos en detalle tanto onCreate () y los otros métodos
de ciclo de vida pertinentes de la clase de actividad.
Estado Dinamizador vs. Estado Persistente

Un objetivo clave de la gestión del ciclo de vida de actividad es garantizar que el estado de la actividad se
guarda y se restaura en los momentos apropiados.Cuando se habla de Estado en este contexto nos referimos a
los datos que se están celebrando en la actualidad dentro de la actividad y la apariencia de la interfaz de
usuario. La actividad podría, por ejemplo, mantener un modelo de datos en la memoria que debe ser guardado
en una base de datos, proveedor de contenido o archivo. Tal información de estado, debido a que persiste entre
una invocación de la aplicación a otra, se conoce como el estado persistente.
La apariencia de la interfaz de usuario (tales como texto introducido en un campo de texto, pero todavía no
comprometida con modelo de datos interno de la aplicación) se conoce como el estado dinámico, ya que está
normalmente sólo conservó durante una única invocación de la aplicación (y también denominado estado de la
interfaz de usuario o la instancia estatal).
Comprender las diferencias entre estos dos estados es importante porque tanto las formas en que se salvan, y
las razones para hacerlo, difieren.
El propósito de salvar el estado persistente es evitar la pérdida de datos que pueden resultar de una actividad
que está siendo asesinado por el sistema de ejecución, mientras que en el fondo. El estado dinámico, por otra
parte, se guarda y restaurado por razones que son ligeramente más complejo.
Consideremos, por el bien de ejemplo, para que una aplicación contiene una actividad (que nos referiremos
como Actividad A) que contiene un campo de texto y algunos botones de radio. Durante el transcurso del uso de
la aplicación, el usuario introduce un texto en el campo de texto y hace una selección de los botones de
radio. Antes de realizar una acción para salvar a estos cambios, sin embargo, el usuario cambia a otra actividad
que causa la actividad de A a ser empujado hacia abajo la Actividad Pila y se coloca en el fondo. Después de
algún tiempo, el sistema de ejecución comprueba que la memoria es baja y, en consecuencia mata Actividad A
para liberar recursos. En lo que se refiere al usuario, sin embargo, la actividad A se coloca simplemente en el
fondo y está listo para ser movido al primer plano en cualquier momento. Al regresar Actividad A al primer plano
el usuario, con bastante razón, esperan que el texto introducido y selecciones de botones de radio a se han
conservado. En este escenario, sin embargo, se habrá creado una nueva instancia de la Actividad A y, si el
estado dinámico no se ha guardado y restaurado, perdió la entrada del usuario anterior.
El objetivo principal de salvar estado dinámico, por lo tanto, es dar la percepción de conmutación sin fisuras
entre las actividades de primer y segundo plano, independientemente del hecho de que las actividades en
realidad pueden haber sido asesinados y reiniciar sin el conocimiento del usuario.
Los mecanismos de ahorro de estado persistente y dinámico se harán más claras en las siguientes secciones
de este capítulo.
Los métodos de ciclo de vida para Android Actividad
Como se explicó anteriormente, la clase de actividad contiene una serie de métodos de ciclo de vida que actúan
como controladores de eventos cuando el estado de un cambio de actividad. Los métodos principales
soportados por la clase Actividad Android son los siguientes:
 onCreate (Bundle savedInstanceState) - El método que se llama cuando se creó por primera vez la
actividad y el lugar ideal para la mayoría de tareas de inicialización que se realizará. El método se pasa un
argumento en la forma de un objeto de paquete que puede contener información de estado dinámico
(normalmente en relación con el estado de la interfaz de usuario) de una invocación antes de la actividad.
 onRestart () - Se llama cuando la actividad está a punto de reiniciar después de haber sido detenido
previamente por el sistema de ejecución.
 onStart () - Siempre llamó inmediatamente después de la llamada a los métodos onCreate () o
onRestart (), este método indica que la actividad que se está a punto de llegar a ser visibles para el
usuario. Esta llamada será seguido por una llamada a onResume () si la actividad se mueve a la parte
superior de la pila de la actividad, o OnStop () en el caso de que se empuja hacia abajo la pila por otra
actividad.
 onResume () - Indica que la actividad se encuentra ahora en la parte superior de la pila de actividad y
es la actividad con la que el usuario está actualmente interactuando.
 onPause () - Indica que una actividad anterior está a punto de convertirse en el primer plano la
actividad. Esta llamada será seguido por una llamada al método ya sea la onResume () o OnStop ()
dependiendo de si la actividad se mueve hacia atrás al primer plano o se vuelve invisible para el
usuario. Se deben tomar medidas dentro de este método para almacenar todos los datos requeridos por la
persistencia de la actividad (por ejemplo, los datos almacenados a un proveedor de contenido, base de
datos o archivo). Este método también debe garantizar que las tareas intensivas de la CPU como la
animación se detienen.
 OnStop () - La actividad ya no es visible para el usuario. Los dos escenarios posibles que pueden
seguir esta convocatoria son un llamado a onRestart () en el caso de que la actividad se traslada a la parte
frontal o OnDestroy () si está siendo terminada la actividad.
 OnDestroy () - La actividad está a punto de ser destruido, ya sea voluntariamente porque la actividad
ha completado sus tareas y ha llamado el método de acabado () o debido a que el tiempo de ejecución está
terminando ya sea para liberar memoria o debido a un cambio de configuración (como el orientación del
cambio de dispositivo). Es importante tener en cuenta que no siempre se realiza una llamada a OnDestroy
() cuando se termina una actividad.
Además de los métodos de ciclo de vida descritos anteriormente, existen dos métodos destinados
específicamente para guardar y restaurar el estado dinámico de una actividad:
 onRestoreInstanceState (Bundle savedInstanceState) - Este método es llamado inmediatamente

después de una llamada al método onStart () en el caso de que la actividad se está reiniciando desde una
invocación anterior en el que se guardó estado. Como con onCreate (), este método se pasa un objeto
Bundle que contiene los datos de estado anteriores. Este método se suele utilizar en situaciones en las que
tiene más sentido para restaurar un estado anterior después de la inicialización de la actividad se ha
realizado en onCreate () y onStart ().
 onSaveInstanceState (Bundle OUTSTATE) - Llamado antes se destruye una actividad para que el
estado dinámico actual (por lo general en relación con la interfaz de usuario) puede ser salvado. El método
se pasa el objeto Bundle en la que el Estado debe ser guardado y que se hace pasar a continuación a
través de la onCreate () y onRestoreInstanceState () métodos cuando se reinicia la actividad. Tenga en
cuenta que este método sólo se llama en situaciones en las que el tiempo de ejecución determine que un
estado dinámico necesita ser salvado.
Al reemplazar los métodos anteriores en una actividad, es importante recordar que con la excepción de
onRestoreInstanceState () y onSaveInstanceState (), la implementación del método debe incluir una llamada al
método correspondiente en la súper clase de actividad. Por ejemplo, el siguiente método reemplaza el método
onRestart (), pero también incluye un llamado a la instancia superclase del método:
protegida onRestart void () {

super.onRestart ();
Log.i (TAG, "onRestart");
}
Si no se hace esta llamada superclase en las anulaciones de método dará lugar a la ejecución lanzar una
excepción durante la ejecución de la actividad.Mientras que las llamadas a la súper clase en el
onRestoreInstanceState () y onSaveInstanceState () son opcionales existen considerables beneficios al hacerlo,
un tema que se tratará en el capítulo titulado Cómo guardar y restaurar el estado de usuario de interfaz de una
Actividad Android.
Vidas Actividad
El último tema a cubrir implica un esquema de todo, visibles y en primer plano los cursos de la vida a través del
cual una actividad pasará durante la ejecución:
 Todo el curso de la vida - El término "toda la vida" se utiliza para describir todo lo que ocurre dentro
de una actividad entre la llamada inicial al método onCreate () y el llamado a OnDestroy () antes de la
terminación de la actividad.
 Lifetime Visible - Cubre los períodos de ejecución de una actividad entre la llamada a onStart () y
OnStop (). Durante este período la actividad es visible para el usuario, aunque puede no ser la actividad
con la que el usuario está actualmente interactuando.
 Lifetime primer plano - Se refiere a los períodos de ejecución entre llamadas al onResume () y
onPause () métodos.
Es importante señalar que una actividad puede pasar a través del primer plano y visibles vidas varias veces
durante el transcurso de toda la vida útil.
Los conceptos de vidas y los métodos de ciclo de vida se ilustran en la Figura 11-2:
Figura 11-2
Resumen
Todas las actividades se derivan de la clase Actividad Android que, a su vez, contiene una serie de métodos de
evento que están diseñados para ser llamado por el sistema de tiempo de ejecución cuando el estado de un
cambio de actividad. Por imperiosas de estos métodos, una actividad puede responder a los cambios de estado
y, en su caso, adoptar las medidas necesarias para salvar y restaurar el estado actual de la actividad y la
aplicación. Estado de actividad se puede considerar como tomar dos formas. El estado persistente se refiere a
los datos que necesita ser almacenada entre invocaciones de la aplicación (por ejemplo, a un archivo o base de
datos). Estado dinámico, por otra parte, se refiere en cambio a la aparición actual de la interfaz de usuario.
En este capítulo, hemos destacado los métodos de ciclo de vida a disposición de las actividades y se cubre el
concepto de vida útil de actividad. En el siguiente capítulo, titulado Actividad Android Estado Cambios - Un
ejemplo de aplicación, vamos a implementar una aplicación de ejemplo que pone gran parte de esta teoría a la
práctica.
12 Android Actividad Estado Cambios - Ejemplo Estudio
Android
Los capítulos anteriores han discutido con cierto detalle los diferentes estados y ciclos de vida de las actividades
que componen una aplicación para Android.En este capítulo, vamos a poner la teoría de la manipulación de los
cambios de estado de actividad en práctica a través de la creación de una aplicación de ejemplo. El propósito de
este ejemplo de aplicación es el de proporcionar una demostración real mundo de una actividad a medida que
pasa a través de una variedad de diferentes estados en el tiempo de ejecución Android.
En el siguiente capítulo, titulado Cómo guardar y restaurar la actividad del Estado en Android estudio , el
proyecto de ejemplo construido en este capítulo se extenderán a demostrar el ahorro y la restauración del
estado de actividad dinámica.
Crear el Ejemplo de proyecto de cambio de estado

El primer paso en este ejercicio es crear el nuevo proyecto. Comience con el lanzamiento de Android Studio y, si
es necesario, el cierre de todos los proyectos abiertos actualmente utilizando el Archivo -> para que aparezca la
pantalla de bienvenida opción Cerrar menú Proyecto.
Seleccione el nuevo proyecto ... opción de inicio rápido de la pantalla de bienvenida y, en el cuadro de diálogo
nuevo proyecto resultante, introduzca StateChange en el campo Nombre de la aplicación y ebookfrenzy.com
como el dominio de la empresa establecer antes de hacer clic en el botón Siguiente.
En la pantalla de factores de forma, activar la opción de teléfono y la tableta y activar el ajuste de API 8 SDK
mínimo: Android 2.2 (Froyo). Continuar para avanzar a través de las pantallas, solicitando la creación de una
actividad en blanco denominada StateChangeActivity con una disposición correspondiente llamado
activity_state_change.
Una vez finalizado el proceso de creación del proyecto, el proyecto StateChange debe aparecer en la ventana
de herramientas Proyecto ubicado a lo largo del borde izquierdo de la ventana principal de Android Studio con el
archivo de origen StateChangeActivity.java pre-cargado en el editor como se ilustra en la Figura 12 -1:
Figura 12-1
La siguiente acción a tomar consiste en el diseño de la interfaz de usuario para la actividad. Este se almacena
en un archivo denominado activity_state_change.xml. Una forma de acceder a este fichero es la de navegar
hacia él en la ventana de herramientas del proyecto en el que se puede encontrar en el StateChange -> src ->
res -> carpeta de presentación. Una vez localizado, haga doble clic en el archivo se cargará en la herramienta
Android Studio Designer. Una opción más rápida, sin embargo, es utilizar el acceso directo Ir al editor de
declaraciones, cuyo propósito es que lo llevarán directamente al archivo y la ubicación en la que se declaró el
elemento seleccionado en la ventana del editor.
En este caso, la disposición activity_state_change se hace referencia en el método onCreate () de la Actividad:
@ Override
setContentView (R.layout.activity_state_change);
}
Para abrir el archivo en el Diseñador, haga clic en la referencia activity_state_change para que se resalte y
pulse la secuencia de atajo de teclado Ctrl-B.Android Studio abra el archivo activity_state_change.xml en la
herramienta Diseñador listo para el trabajo de diseño para comenzar.

Con el diseño de la interfaz de usuario cargado en la herramienta de diseño, ahora es el momento de diseñar la
interfaz de usuario para la aplicación de ejemplo. En lugar de la "¡Hola, mundo!" TextView actualmente presente
en el diseño de la interfaz de usuario, la actividad efectivamente requiere una vista EditarTexto. Seleccione el
objeto TextView en el lienzo Designer y pulse la tecla Supr en el teclado para eliminarlo de la concepción.
Desde la paleta situada en el lado izquierdo del Diseñador, busque la categoría de los campos de texto y haga
clic y arrastre un componente de texto sin formato a la representación visual de la pantalla del
dispositivo. Mueva el componente al centro de la pantalla para que aparezcan las directrices del centro y
colocarlo en su lugar para que el diseño se asemeja a la de la figura 12-2.
Figura 12-2
Observe que el icono de la bombilla ha aparecido junto a la vista lo que indica que la asistencia está disponible
para nosotros en la configuración de este componente. Cuando se trabaja con vistas EditText en una interfaz de
usuario de Android, es necesario declarar el tipo de entrada para la vista. Esto simplemente define el tipo de
texto o datos que serán introducidos por el usuario. Por ejemplo, si el tipo de entrada está establecido en el
teléfono, el usuario será restringido a entrar dígitos numéricos en la vista. Alternativamente, si el tipo de entrada
está establecido en TextCapCharacters, la entrada será por defecto caracteres en mayúsculas. La configuración
del tipo de entrada también se pueden combinar.
A los efectos de este ejemplo, vamos a establecer el tipo de entrada para apoyar la introducción de texto en
general. Para ello, haga clic en el icono de la bombilla seguida de la derecha frente a la flecha al final del
mensaje que describe el problema. En la lista de posibles soluciones (Figura 12-3) haga clic en la opción
Agregar atributo InputType:
Figura 12-3
Desde el diálogo Establecer valor de atributo resultante, seleccione la opción de texto desde el menú
desplegable.
El paso final en el proceso de diseño de la interfaz de usuario es aumentar la anchura del componente
TextView. Con el componente seleccionado en el diseño, desplácese por la lista de atributos en el panel
Propiedades hasta que el atributo width está a la vista e introduzca un valor de 200dp como se indica en la
Figura 12-4:
Figura 12-4
Anulación de los métodos de ciclo de vida de actividad

En este punto, el proyecto contiene una sola actividad denominada StateChangeActivity, que se deriva de la
clase Android ActionBarActivity. El código fuente de esta actividad está contenida en el archivo
StateChangeActivity.java que ya debería estar abierto en una sesión de editor y representada por una pestaña
en la barra de pestañas editor. En el caso de que el archivo ya no está abierta, navegue hasta que en el panel
de la ventana de herramientas de Proyectos (StateChange -> aplicación -> src -> principal -> Java ->
com.ebookfrenzy.statechange -> StateChangeActivity) y haga doble clic en él para cargar el archivo en el
editor. Una vez cargado el código debe ser el siguiente:
com.ebookfrenzy.statechange paquete;
public class StateChangeActivity extiende ActionBarActivity {
@ Override
}
@ Override

presente.
. getMenuInflater () inflar (R.menu.state_change, menú);
return true;
}
@ Override
return true;
}
}
Hasta ahora el único método de ciclo de vida se reemplaza por la actividad es el método onCreate (), que se ha
implementado para llamar la instancia superclase del método antes de configurar la interfaz de usuario para la
actividad. Ahora modificaremos este método de forma que produzca un mensaje de diagnóstico en el panel
Android Estudio LogCat cada vez que se ejecuta. Para ello, vamos a utilizar la clase Log, que requiere que
importamos android.util.Log y declaramos una etiqueta que nos permitirá filtrar estos mensajes en la salida del
registro:
android.util.Log importación;
estática TAG final String privado = "com.ebookfrenzy.StateChange";
@ Override
Log.i (TAG, "onCreate");
}
@ Override

presente.
. getMenuInflater () inflar (R.menu.state_change, menú);
return true;
}
@ Override
return true;
}
}
La siguiente tarea es reemplazar algunos más métodos, cada uno que contiene una llamada de registro
correspondiente. Estos métodos de reemplazo pueden añadir manualmente o generados utilizando el Alt-Insert
atajo de teclado como se indica en el capítulo titulado Los fundamentos de la Android Estudio Editor de
código. Tenga en cuenta que el registro de llamadas todavía tendrá que agregar manualmente si los métodos se
generan automáticamente:
@ Override
protegida onStart void () {
super.onStart ();
Log.i (TAG, "onStart");
}
@ Override
protected void onResume () {
super.onResume ();
Log.i (TAG, "onResume");
}
@ Override
protegida onPause void () {
super.onPause ();
Log.i (TAG, "onPause");
}
@ Override
protegida OnStop void () {
super.onStop ();
Log.i (TAG, "OnStop");
}
@ Override
protegida onRestart void () {
super.onRestart ();
Log.i (TAG, "onRestart");
}
@ Override
protegida OnDestroy void () {
super.onDestroy ();
Log.i (TAG, "OnDestroy");
}
@ Override
protected void onSaveInstanceState (Bundle OUTSTATE) {
super.onSaveInstanceState (OUTSTATE);
Log.i (TAG, "onSaveInstanceState");
}
@ Override
protected void onRestoreInstanceState (Bundle savedInstanceState) {
super.onRestoreInstanceState (savedInstanceState);
Log.i (TAG, "onRestoreInstanceState");
}
Filtrar el Panel LogCat

El propósito del código añadido a los métodos reemplazados en StateChangeActivity.java es a la salida
información de registro en el panel LogCat dentro de la ventana de la herramienta Android. Sin filtros definidos,
el registro aparecerá una lista de todos los eventos que tiene lugar dentro del dispositivo o emulador por lo que
es difícil encontrar los mensajes de registro para nuestros métodos sobrescritos. Antes de ejecutar la aplicación,
por lo tanto, se recomienda crear un filtro que, cuando se selecciona, se asegurará de que sólo se muestran los
mensajes de registro que contienen la etiqueta declarada en nuestra actividad.
Comienza mostrando la ventana de herramientas Android utilizando el botón de menú de herramientas situada
en la esquina izquierda de la barra de estado o la Alt-6 atajo de teclado. Dentro de la ventana de la herramienta,
asegúrese de que los dispositivos | pestaña Logcat se selecciona antes de acceder al menú de la esquina
superior derecha del panel (que probablemente leerá Actualmente Sin filtros). Desde este menú, seleccione la
opción de menú Configuración Editar filtro como se muestra en la Figura 12-5:
Figura 12-5
En el cuadro de diálogo Nuevo filtro Logcat Crear (Figura 12-6), el nombre del ciclo de vida del filtro y, en el
campo por Tag Log (regex), introduzca el valor declarado en la etiqueta StateChangeActivity.java (en el ejemplo
de código anterior era com.ebookfrenzy .StateChange pero pueden haber cambiado esto para reflejar la URL de
su empresa).
Figura 12-6
Al completar los cambios, haga clic en el botón Aceptar para crear el filtro y cerrar el diálogo. En vez de
enumerar Sin filtros, el filtro recién creado ahora debe ser seleccionado en la ventana de herramientas Android.
Para obtener resultados óptimos, la aplicación debe ejecutarse en un dispositivo Android física, cuyos detalles
se pueden encontrar en el capítulo titulado Aplicaciones Prueba de Android en un dispositivo Android físico con
ADB. Con el dispositivo configurado y conectado al equipo de desarrollo, haga clic en el botón de ejecución
representado por un triángulo verde ubicado en la barra de herramientas de Android Studio como se muestra en
la Figura 12-7 a continuación, seleccione la opción Ejecutar -> opción Ejecutar ... del menú o utilizar las teclas
Shift + F10 atajo de teclado:
Figura 12-7
Seleccione el dispositivo Android física del Elija diálogo Dispositivo si aparece (suponiendo que todavía no lo ha
configurado para que sea el destino predeterminado). Después de Android Studio ha incorporado la aplicación e
instalado en el dispositivo debe poner en marcha y se ejecuta en segundo plano.
Una revisión del panel LogCat debe indicar que hasta el momento se han activado los métodos (teniendo
cuidado para asegurarse de que se selecciona el filtro del ciclo de vida creado en la sección anterior para filtrar
los eventos de registro que no son actualmente de interés para nosotros):
Figura 12-8
Experimentar con la Actividad

Con el diagnóstico de trabajo, ahora es el momento de ejercer la aplicación con el fin de profundizar en el
conocimiento de los cambios de estado de actividad del ciclo de vida. Para empezar, tenga en cuenta la
secuencia inicial de eventos de registro en el panel LogCat:
onCreate
onStart
onResume
Claramente, los cambios iniciales estatales son exactamente como se indica en la Figura 9 2. Tenga en cuenta,
sin embargo, que una llamada no fue hecho para onRestoreInstanceState (), ya que el tiempo de ejecución
Android detectó que no había estado para restaurar en esta situación.
Toque en el icono Inicio en la barra de estado inferior de la pantalla del dispositivo y observar la secuencia de
llamadas a métodos reportados en el registro de la siguiente manera:
onPause
onSaveInstanceState
OnStop
En este caso, el tiempo de ejecución se ha dado cuenta de que la actividad ya no está en el primer plano es, no
es visible para el usuario y se ha detenido la actividad, pero no sin dar una oportunidad para que la actividad de
guardar el estado dinámico. Dependiendo de si el tiempo de ejecución en última instancia, destruyó la actividad
o simplemente reinicia ella, la actividad o bien se le notificará que se ha reiniciado a través de una llamada a
onRestart () o pasará a través de la secuencia de creación de nuevo cuando el usuario vuelve a la actividad.
Como se indica en la Comprensión Aplicación para Android y Actividad Ciclos de vida, la destrucción y la
reconstrucción de la actividad pueden ser provocados por hacer un cambio de configuración en el dispositivo,
tales como la rotación de vertical a horizontal. Para ver esto en acción, basta con girar el dispositivo mientras la
aplicación StateChange está en primer plano. Cuando se utiliza el emulador, rotación dispositivo puede ser
simulado utilizando el atajo de teclado Ctrl-F12 o pulsando el número 7 en el teclado teclado mientras Bloq Num
está desactivado. Tenga en cuenta, sin embargo, que la versión actual del emulador falla al manejar la rotación
correctamente. La secuencia resultante de llamadas a métodos en el registro debe ser el siguiente:
onPause
onSaveInstanceState
OnStop
OnDestroy
onCreate
onStart
onRestoreInstanceState
onResume
Es evidente que el sistema de ejecución ha dado la actividad una oportunidad de guardar el estado antes de ser
destruida y reiniciado.
Resumen
El viejo adagio de que una imagen vale más que mil palabras tiene tan cierto para los ejemplos en el
aprendizaje de un nuevo paradigma de programación. En este capítulo, hemos creado un ejemplo de aplicación
de Android para el fin de demostrar los diferentes estados del ciclo de vida a través de las cuales es probable
que pasar una actividad. En el transcurso del desarrollo del proyecto en este capítulo, también se fijó en un
mecanismo para la generación de información de registro de diagnóstico dentro de una actividad.
En el próximo capítulo, vamos a ampliar el proyecto de ejemplo StateChange para demostrar cómo guardar y
restaurar el estado dinámico de una actividad.
13 Guardar y restaurar la actividad del Estado en Android

Estudio
Si los capítulos anteriores han logrado su objetivo, que ahora debe ser un poco más claro en cuanto a la
importancia de guardar y restaurar el estado de una interfaz de usuario en determinados puntos en el tiempo de
vida de una actividad.
En este capítulo, vamos a ampliar la aplicación de ejemplo creada en Android Actividad Cambios de estado - Un
Estudio Android Ejemplo para demostrar los pasos necesarios para guardar y restaurar el estado cuando se
destruye una actividad y recreado por el sistema de ejecución.
Un componente clave de guardar y restaurar el estado dinámico implica el uso de la clase Android SDK Bundle,
un tema que también se tratará en este capítulo.
Grabar estado dinámicamente

Una actividad, como ya hemos aprendido, se le da la oportunidad de guardar la información de estado dinámico
a través de una llamada del sistema de ejecución de la implementación de la actividad del método
onSaveInstanceState (). Paso a través de como argumento para el método es una referencia a un objeto de
paquete en el que tendrá el método para almacenar cualquier dato dinámico que necesita ser salvado. El objeto
Bundle es almacenada por el sistema de ejecución en nombre de la actividad y, posteriormente, pasó a través
de un argumento a onCreate de la actividad () y onRestoreInstanceState () métodos, siempre y cuando se les
llama. Los datos pueden ser recuperados desde el objeto Bundle dentro de estos métodos y se utilizan para
restaurar el estado de la actividad.
Guardado predeterminado de la interfaz de usuario del Estado

En el capítulo anterior, la salida de diagnóstico desde el ejemplo de aplicación StateChange mostró que una
actividad pasa por una serie de cambios de estado cuando el dispositivo en el que se está ejecutando es girado
lo suficiente para desencadenar un cambio de orientación.
Inicie la aplicación StateChange una vez más, esta vez de entrar en algún texto en el campo EditarTexto antes
de realizar la rotación dispositivo. Después de haber girado el dispositivo, la siguiente secuencia de cambio de
estado debe aparecer en la ventana LogCat:
onPause
onSaveInstanceState
OnStop
OnDestroy
onCreate
onStart
onRestoreInstanceState
onResume
Es evidente que esto ha resultado en la actividad que está siendo destruido y re-creado. Una revisión de la
interfaz de usuario de la aplicación en ejecución, sin embargo, debe demostrar que el texto introducido en el
campo EditarTexto se ha conservado. Dado que la actividad fue destruido y reconstruido, y que no añadimos
ningún código específico para asegurarse de que el texto se guarda y se restaura, este comportamiento requiere
una explicación.
En realidad la mayoría de los widgets de vista incluidas en el SDK de Android ya implementan el
comportamiento necesario para guardar automáticamente y restaurar el estado cuando se reinicia una
actividad. El único requisito para habilitar este comportamiento es que el onSaveInstanceState () y
onRestoreInstanceState () métodos de reemplazo en la actividad para incluir las llamadas a los métodos
equivalentes de la super clase:
@ Override
}
@ Override
}
El ahorro automático de estado para una vista de la interfaz de usuario se puede desactivar en el archivo de
diseño XML estableciendo el androide: propiedad saveEnabled false. A los efectos de un ejemplo, vamos a
desactivar el mecanismo automático de ahorro de estado para la vista EditarTexto en el diseño de la interfaz de
usuario y luego agregar el código en la aplicación para guardar manualmente y restaurar el estado de la vista.
Para configurar la vista EditarTexto tal que el estado no se guardará y restaurada en el caso de que se reinicie
la actividad, edite el archivo activity_state_change.xml para que la entrada de la vista es el siguiente (tenga en
cuenta que el XML se puede editar directamente haciendo clic en la ficha Texto en el borde inferior del panel
Designer):
<EditarTexto
android: id = "@ + / Identificación del EDITTEXT"
android: saveEnabled = "false"
android: InputType = "text"
android: layout_centerHorizontal = "true"
android: width = "200dp" />
Después de hacer el cambio, ejecute la aplicación, introducir texto y girar el dispositivo para comprobar que el
texto ya no se guarda y se restaura antes de proceder.
La Clase Bundle
Para situaciones en las que el estado necesita para ser salvo más allá de la funcionalidad por defecto
proporcionado por los componentes de interfaz de usuario, la clase Bundle proporciona un contenedor para el
almacenamiento de datos utilizando un mecanismo par clave-valor. Las teclas tienen la forma de valores de
cadena, mientras que los valores asociados con esas llaves pueden ser en forma de un valor simple o cualquier
objeto que implemente la interfaz de Android parcelable. Una amplia gama de clases ya implementa la interfaz
parcelable. Clases personalizadas se pueden hacer "parcelable" mediante la aplicación del conjunto de los
métodos definidos en la interfaz parcelable (cuyos detalles se pueden encontrar en la documentación de Android
enhttp://developer.android.com/reference/android/os/Parcelable.html ).
La clase Bundle también contiene un conjunto de métodos que se pueden utilizar para obtener y definir pares
clave-valor para una variedad de tipos de datos que incluye los dos tipos primitivos (como los operadores
booleanos, char, doble y valores flotantes) y objetos (como cadenas y CharSequences ).
A los efectos de este ejemplo, y después de haber desactivado el guardado automático de texto para la vista
EditarTexto, tenemos que asegurarnos de que el texto introducido en el campo EditarTexto por el usuario se
guarda en el objeto Bundle y posteriormente restaurada. Esto servirá como una demostración de cómo guardar
manualmente y restaurar el estado dentro de una aplicación para Android y se logrará mediante el
putCharSequence () y getCharSequence () de la clase Bundle respectivamente.
Guardar el Estado
El primer paso para extender la aplicación StateChange es asegurarse de que el texto introducido por el usuario
se extrae del componente EditarTexto dentro del método onSaveInstanceState () de la actividad
StateChangeActivity, y luego guarda como un par clave-valor en el objeto Bundle.
Con el fin de extraer el texto del objeto EditarTexto primero tenemos que identificar dicho objeto en la interfaz de
usuario. Evidentemente, se trata de salvar la distancia entre el código Java para la actividad (que figura en el
archivo de código fuente StateChangeActivity.java) y la representación XML de la interfaz de usuario (incluido en
el archivo de recursos activity_state_change.xml). Con el fin de extraer el texto introducido en el componente de
EditarTexto que necesitamos para acceder a dicho objeto de interfaz de usuario.
Cada componente dentro de una interfaz de usuario está asociada con un identificador único. De forma
predeterminada, la herramienta Diseñador construye el ID de un componente recién añadida por el tipo de
objeto. Si más de una vista del mismo tipo está contenida en la disposición el nombre del tipo es seguido de un
número secuencial (aunque esto puede, y debe, ser cambiado a algo más significativo por el promotor). Como
puede verse por el control del panel de componentes dentro de la ventana principal de Android Studio cuando
se selecciona el archivo activity_state_change.xml y la herramienta Diseñador mostrada, el componente
EditarTexto se ha asignado el ID EDITTEXT:
Figura 13-1
Como se indica en el capítulo titulado La Anatomía de una aplicación Android, todos los recursos que componen
una aplicación se compilan en una clase denominada R. Entre esos recursos son los que definen los diseños,
incluyendo el diseño de nuestra actividad actual. Dentro de la clase R es una subclase llamada diseño, que
contiene los recursos de diseño, y dentro de esa subclase es nuestro diseño activity_state_change. Con este
conocimiento, podemos hacer una llamada al método findViewById () de nuestra actividad objeto de obtener una
referencia al objeto EDITTEXT de la siguiente manera:
textBox EditarTexto final = (EditarTexto) findViewById (R.id.editText);
Después de haber obtenido una referencia al objeto EditarTexto y asignado a TextBox, ahora podemos obtener
el texto que contiene llamando al método del objeto getText (), que, a su vez, devuelve el texto actual en la
forma de un objeto CharSequence:
CharSequence usertext = textBox.getText ();
Por último, podemos guardar el texto utilizando el método del objeto Bundle putCharSequence (), pasando por la
llave (esto puede ser cualquier valor de cadena, pero en este caso, la declararemos como "savedText") y el
objeto usertext como argumentos:
outState.putCharSequence ("savedText", usertext);
Llevar todo esto junto nos da un método modificado onSaveInstanceState () en el archivo

StateChangeActivity.java que dice lo siguiente (teniendo en cuenta también la directiva de importación
complementario para android.widget.EditText):
android.widget.EditText importación;

.
.
.
Log.i (TAG, "onSaveInstanceState");
textBox última EditarTexto =

(EditarTexto) findViewById (R.id.editText);
CharSequence usertext = textBox.getText ();
outState.putCharSequence ("savedText", usertext);
}
.
.
.
Ahora que se han tomado medidas para salvar el estado, la siguiente fase es asegurar que se restaura cuando
sea necesario.
Restauración del Estado

El estado dinámico ahorrado puede ser restaurada en los métodos de ciclo de vida que se pasan el objeto
Bundle como argumento. Esto deja el programador con la opción de usar ya sea onCreate () o
onRestoreInstanceState (). El método a utilizar dependerá de la naturaleza de la actividad. En los casos en que
es mejor restaurado estado después de haber realizado tareas de inicialización de la actividad, el método
onRestoreInstanceState () es en general más adecuado.A los efectos de este ejemplo vamos a agregar código
al método onRestoreInstanceState () para extraer el estado guardado del paquete usando la tecla
"savedText". A continuación, podemos visualizar el texto en el componente EditText1 utilizando el método
setText del objeto ():
@ Override
Log.i (TAG, "onRestoreInstanceState");
textBox última EditarTexto =

(EditarTexto) findViewById (R.id.editText);
CharSequence usertext =
savedInstanceState.getCharSequence ("savedText");
textBox.setText (usertext);
}
Todo lo que queda es una vez más para generar y ejecutar la aplicación StateChange. Una vez que se ejecuta y
en primer plano, toque el componente EditarTexto e introduzca algún texto antes de girar el dispositivo a otra
orientación. Mientras que se perdieron previamente el texto cambia, el nuevo texto se mantiene dentro de los
componentes EDITTEXT gracias al código que hemos añadido a la actividad en este capítulo.
Resumen
El ahorro y la restauración del estado dinámico de una aplicación para Android es simplemente una cuestión de
aplicación del código apropiado en los métodos de ciclo de vida adecuadas. Para la mayoría de los puntos de
vista de la interfaz de usuario, esto se maneja de forma automática por la súper clase de actividad. En otros
casos, esto normalmente consiste en extraer los valores y ajustes en el método onSaveInstanceState () y
guardar los datos como pares de valores clave dentro del objeto Bundle pasado a través de la actividad por
parte del sistema de ejecución.
Estado se puede restaurar ya sea en el onCreate () o la onRestoreInstanceState () de la actividad de extracción
de valores desde el objeto Bundle y la actualización de la actividad basándose en los valores almacenados.
En este capítulo, hemos utilizado estas técnicas para actualizar el proyecto StateChange de modo que la
actividad conserva cambios a través de la destrucción y posterior reconstrucción de una actividad.
14 Entendiendo Vistas Android, Ver grupos y diseños en
Android Estudio
Con la posible excepción de escuchar el streaming de audio, la interacción de un usuario con un dispositivo
Android es principalmente visual y táctil en la naturaleza. Toda esta interacción se lleva a cabo a través de las
interfaces de usuario de las aplicaciones instaladas en el dispositivo, incluyendo tanto las aplicaciones
integradas y aplicaciones de terceros instaladas por el usuario. No debería ser ninguna sorpresa, por lo tanto,
que un elemento clave de desarrollo de aplicaciones para Android implica el diseño y creación de interfaces de
usuario.
Dentro de este capítulo, el tema de la estructura de la interfaz de usuario de Android será cubierta, junto con una
visión general de los diferentes elementos que se pueden juntar para hacer una interfaz de usuario; a saber,
Vistas, Ver grupos y diseños.
Diseñar para diferentes dispositivos Android

El término "dispositivo Android" abarca una amplia gama de tabletas y teléfonos inteligentes productos con
diferentes tamaños de pantalla y resoluciones.Como resultado, las interfaces de usuario de aplicaciones ahora
deben ser cuidadosamente diseñados para asegurar la correcta presentación en la más amplia gama de
tamaños de pantalla como sea posible. Una parte clave de esto es asegurar que los diseños de interfaz de
usuario cambiar el tamaño correctamente cuando se ejecuta en diferentes dispositivos. Esto sólo se podrá lograr
a través de una cuidadosa planificación y el uso de los controladores de distribución se describen en este
capítulo.
También es importante tener en cuenta que la mayoría de los teléfonos inteligentes y las tabletas basado en
Android puede ser considerado por el usuario, tanto en orientación vertical y horizontal. Una interfaz de usuario
bien diseñado debe ser capaz de adaptarse a estos cambios y hacer los ajustes de diseño sensatas para utilizar
el espacio de pantalla disponible en cada orientación.
Vistas y Ver grupos

Cada elemento de una interfaz de usuario es una subclase de la clase Vista Android (sea android.view.View
precisos). El SDK de Android proporciona un conjunto de vistas predefinidas que se pueden utilizar para
construir una interfaz de usuario. Ejemplos típicos son elementos estándar como el botón, CheckBox, clases
ProgressBar y TextView. Estos puntos de vista también se les conoce como widgets o componentes. Para
conocer los requisitos que no se cumplen los reproductores suministrados con el SDK, nuevos puntos de vista
pueden ser creadas por subclases y extender una clase existente, o la creación de un componente
completamente nuevo mediante la construcción directamente en la parte superior de la clase View.
Una vista puede también estar compuesto de múltiples otros puntos de vista (conocidos de otra manera como
una vista compuesta). Estos puntos de vista son subclases de la clase Android ViewGroup
(android.view.ViewGroup), que es en sí misma una subclase de View. Un ejemplo de tal punto de vista es la
RadioGroup, que está destinado a contener múltiples RadioButton objetos de tal manera que sólo uno puede
estar en la posición "on" en cualquier momento. En términos de estructura, vistas compuestas constan de una
sola vista padre (derivada de la clase ViewGroup y conocido de otra manera como una vista recipiente o
elemento raíz) que es capaz de contener otras vistas (conocidos como vistas niño).
Otra categoría de vista de contenedor basado ViewGroup es la del controlador de distribución.
Android Controladores de Distribución

Además de los puntos de vista de estilo para widgets discutidos en la sección anterior, el SDK también incluye
un conjunto de puntos de vista que se refiere como diseños. Diseños son vistas de contenedores (y, por lo tanto,
una subclase de ViewGroup) diseñados con el único propósito de controlar cómo vistas niño se colocan en la
pantalla.
El SDK de Android incluye los siguientes puntos de vista de diseño que se pueden utilizar dentro de un diseño
de la interfaz de usuario de Android:
 LinearLayout - Posiciones niño vistas en una sola fila o columna en función de la orientación
seleccionada. Un valor de peso se puede establecer en cada niño para especificar la cantidad de espacio
de la disposición de que los niños deben ocupar en relación con otros niños.
 TableLayout - Organiza visitas del niño en un formato de cuadrícula de filas y columnas. Cada fila
dentro de una tabla está representado por un niño objeto TableRow, que, a su vez, contiene un objeto de
vista para cada célula.
 FrameLayout - El propósito de la FrameLayout es asignar un área de la pantalla, típicamente para los

fines de mostrar una sola vista. Si se añaden varias vistas niño que, por defecto, aparecerá en la parte
superior de uno al otro situado en la esquina superior izquierda del área de diseño. Posicionamiento
alternativo de opiniones individuales del niño se puede lograr mediante el establecimiento de los valores de
gravedad en cada niño. Por ejemplo, el establecimiento de una gravedad center_vertical en un niño va a
hacer que se coloca en el centro vertical de la vista que contiene FrameLayout.
 RelativeLayout - Probablemente el más potente y flexible de los controladores de distribución, lo que

permite vistas niño para ser colocados tanto en relación con los demás y la vista de diseño que contiene
mediante la especificación de las alineaciones y los márgenes de los puntos de vista del niño. Por ejemplo,
niño View A puede estar configurado para ser colocado en el centro vertical y horizontal de la vista que
contiene RelativeLayout. Ver B, por otro lado, puede también ser configurado para estar centrado
horizontalmente dentro de la vista de diseño, pero posicionado 30 píxeles por encima del borde superior de
la vista A, con lo que la posición vertical relativa a la de gestor de Vista A. El RelativeLayout puede ser de
uso particular en el diseño de una interfaz de usuario que deben trabajar en una variedad de tamaños de
pantalla y orientaciones.
 AbsoluteLayout - Permite vistas niño a colocarse en X e Y las coordenadas específico dentro de la

vista de diseño que contiene. El uso de este diseño se desaconseja ya que carece de la flexibilidad
necesaria para responder a los cambios en el tamaño y la orientación de la pantalla.
 GridLayout - El GridLayout es relativamente un nuevo controlador de distribución que se introdujo

como parte de Android 4.0. Un ejemplo GridLayout se divide por líneas invisibles que forman una
cuadrícula que contiene filas y columnas de celdas. Puntos de vista del niño se colocan en las células y
pueden ser configurados para cubrir varias celdas horizontal y verticalmente permitiendo una amplia gama
de opciones de diseño para ser implementado de forma rápida y sencilla. Los espacios entre los
componentes de un GridLayout pueden implementarse mediante la colocación de un tipo especial de vista
llamada una vista espacial en las células adyacentes, o mediante el establecimiento de parámetros de
margen.
Al considerar el uso de diseños en la interfaz de usuario de una aplicación Android vale la pena tener en cuenta
que, como se indica en la siguiente sección, se pueden anidar dentro de sí para crear un diseño de interfaz de
usuario de casi cualquier nivel necesario de complejidad.
La vista Jerarquía
Cada vista en una interfaz de usuario representa un área rectangular de la pantalla. Una vista es responsable de
lo que está dibujado en ese rectángulo y para responder a los acontecimientos que se producen en la parte de
la pantalla (como un evento de contacto).
Una pantalla de interfaz de usuario se compone de una jerarquía de vistas con una vista raíz colocado en la
parte superior de las vistas de árbol y el niño posicionado en las ramas de abajo. El hijo de una vista de
contenedor aparece en la parte superior de la vista padre y se ve obligado a aparecer dentro de los límites del
área de visualización de la vista padre. Consideremos, por ejemplo, la interfaz de usuario ilustrada en la Figura
14-1:
Figura 14-1
Además de las vistas visibles los botones y casillas de verificación, la interfaz de usuario realmente incluye una
serie de puntos de vista de diseño que controlan cómo se posicionan las vistas visibles. Figura 14-2 muestra
una visión alternativa de la interfaz de usuario, esta vez destacando la presencia de las vistas de presentación
en relación con los puntos de vista del niño:
Figura 14-2
Como se discutió anteriormente, las interfaces de usuario están construidas en forma de una jerarquía de vistas
con una vista de la raíz en la parte superior.Siendo este el caso, también puede visualizar el ejemplo de interfaz
de usuario de arriba en forma de árbol vista ilustrada en la Figura 14-3:
Figura 14-3
El diagrama de vista de jerarquía da probablemente la visión general más clara de la relación entre las distintas
vistas que conforman la interfaz de usuario se muestra en la Figura 14-1. Cuando se muestra una interfaz de
usuario para el usuario, el tiempo de ejecución Android camina por la jerarquía de la vista, a partir de la opinión
de la raíz y de trabajo por el árbol, ya que hace que cada vista.
La creación de interfaces de usuario

Con una mejor comprensión de los conceptos de puntos de vista, diseños y la jerarquía de la vista, los
siguientes capítulos se centrarán en los pasos involucrados en la creación de interfaces de usuario para
actividades de Android. De hecho, hay tres enfoques diferentes para el diseño de interfaz de usuario: Con la
herramienta Android Studio Designer, archivos de recursos de diseño de escritura XML o escribir código Java,
cada uno de los cuales serán cubiertos.
Resumen
Cada elemento dentro de una pantalla de interfaz de usuario de una aplicación para Android es una vista que se
subclase en última instancia de la clase android.view.View. Cada vista representa un área rectangular de la
pantalla del dispositivo y es responsable tanto de lo que aparece en ese rectángulo y para el manejo de eventos
que tienen lugar dentro de los límites de la vista. Las vistas múltiples pueden combinarse para crear una única
vista compuesta. Los puntos de vista dentro de una vista compuesta somos hijos de la vista de contenedor que
generalmente es una subclase de android.view.ViewGroup (que es en sí misma una subclase de
android.view.View). Una interfaz de usuario está compuesta de puntos de vista construidos en la forma de una
jerarquía de vistas.
El SDK de Android incluye una gama de puntos de vista pre-construidos que se pueden utilizar para crear una
interfaz de usuario. Estos incluyen componentes básicos tales como campos de texto y botones, además de una
serie de gestores de diseño que se pueden utilizar para controlar el posicionamiento de puntos de vista del
niño. En el caso de que las opiniones suministrados no cumplen con un requisito específico, vistas
personalizadas se pueden crear, ya sea mediante la ampliación o la combinación de vistas existentes, o creando
una subclase android.view.View y la creación de una nueva clase de vista.
Las interfaces de usuario pueden ser creados usando la herramienta Android Studio Designer, archivos de
recursos de diseño de escritura XML o escribiendo código Java. Cada uno de estos enfoques se tratarán en los
capítulos que siguen.
15 El diseño de una interfaz de usuario utilizando la
herramienta Diseñador Android Estudio
Con mucho, el mecanismo más fácil y más productivo para el diseño de una interfaz de usuario para una
aplicación de Android es hacer uso de la herramienta Android Studio Designer. El objetivo de este capítulo es
proporcionar una visión general de cómo crear una interfaz de usuario utilizando esta herramienta. El ejercicio
se incluye en este capítulo también se utilizará como una oportunidad para perfilar la creación de una actividad a
partir de un "escueto" proyecto Android Studio.
Después de haber cubierto el uso del Diseñador Android de estudio, el capítulo también se ofrecerá una visión
general de los conceptos detrás de los archivos de recursos de diseño de edición de XML escrito manualmente
y antes de la introducción de la herramienta Visor de Jerarquía.
Diseñador Android Estudio Herramienta Ejemplo

El primer paso en esta fase del ejemplo es la creación de un nuevo proyecto Android Studio. Comienza, por lo
tanto, con el lanzamiento de Android Estudio y cierre de los proyectos previamente abiertos al seleccionar
Archivo -> opción de menú Cerrar proyecto. Dentro de la pantalla de bienvenida clic Android Studio en el nuevo
proyecto ... opción de inicio rápido para mostrar la primera pantalla del cuadro de diálogo nuevo proyecto.
Entrando LayoutSample en el campo Nombre de la aplicación y ebookfrenzy.com como el ajuste de dominio de
la empresa antes de hacer clic en el botón Siguiente.
En los ejemplos anteriores, hemos solicitado que Android Estudio crear una actividad de plantilla para el
proyecto. Nosotros, sin embargo, a utilizar este tutorial para aprender a crear una actividad totalmente nueva y
archivo de recursos de disposición correspondiente de forma manual, así que asegúrese de que la opción
Añadir No Actividad está seleccionado antes de hacer clic en Finalizar para crear el nuevo proyecto.
Creación de una nueva actividad

Una vez que el proceso de creación del proyecto se ha completado, la ventana principal de Android Estudio
debería aparecer con un fondo blanco que contiene un mensaje que dice "No hay archivos están abiertos".
El siguiente paso en el proyecto es la creación de una nueva actividad. Este será un valioso ejercicio de
aprendizaje, ya que hay muchos casos en el curso del desarrollo de aplicaciones Android en nuevas actividades
se deben crear desde cero.
Comienza mostrando la ventana de herramientas Proyecto utilizando la Alt-1 atajo de teclado. Una vez
visualizado, desplegar la jerarquía haciendo clic en el derecho flechas hacia próximos a las entradas de la
ventana del proyecto. El objetivo aquí es tener acceso a la LayoutSample -> aplicación -> src -> principal ->
Java -> carpeta com.ebookfrenzy.layoutsample en la jerarquía del proyecto. Una vez que el nombre del paquete
es visible, haga clic derecho sobre él y seleccione Nuevo -> Actividad -> opción de menú Actividad en blanco
como se ilustra en la Figura 16-1:
Figura 16-1
En el cuadro de diálogo Nueva actividad resultante, el nombre del nuevo LayoutSampleActivity actividad y la
activity_layout_sample diseño.
Para que una aplicación sea capaz de ejecutar en un dispositivo que tiene que tener una actividad designada
como la actividad de lanzamiento. Sin una actividad lanzador, el sistema operativo no sabrá que la actividad se
inicie cuando los primeros lanzamientos de aplicaciones y, como tal, la aplicación no se iniciará. Dado que este
ejemplo sólo tiene una actividad, tiene que ser designado como la actividad lanzador de la aplicación, así que
asegúrate de que la opción Actividad Launcher está seleccionado antes de hacer clic en el botón Finalizar.
En este punto Android Estudio debería haber añadido dos archivos para el proyecto. El archivo de código fuente
de Java para la actividad debe estar ubicado en el LayoutSample -> aplicación -> src -> principal -> Java ->
carpeta com.ebookfrenzy.layoutsample y también debería haber sido precargados en la ventana del editor.
Además, el archivo XML para el diseño de la interfaz de usuario debe haber sido creado en el LayoutSample ->
aplicación -> src -> res - -> carpeta layout> principal.
Por último, se debería haber añadido la nueva actividad en el fichero AndroidManifest.xml y designada como la
actividad de lanzamiento. El archivo de manifiesto se puede encontrar en la ventana del proyecto bajo la
LayoutSample -> aplicación -> src -> carpeta principal y debe contener la siguiente XML:

<Xmlns manifiestos: androide = "http://schemas.android.com/apk/res/android"
paquete = "com.ebookfrenzy.layoutsample">
<Application
android: allowBackup = "true"
android: icon = "@ estirable / ic_launcher"
android: label = "@ string / nombre_apl"
android: theme = "@ style / AppTheme">
<Actividad
android: name = ". LayoutSampleActivity"
android: label = "@ string / title_activity_layout_sample">
<Intención de filtro>
<Acción android: name = "android.intent.action.MAIN" />
<Categoría
android: name = "android.intent.category.LAUNCHER" />
</ Intención de filtro>
</ Actividad>
</ Application>
</ Manifiesto>

Busque y haga doble clic en el archivo de diseño activity_layout_sample.xml ubicado en el LayoutSample ->
aplicación -> src -> principal -> res -> carpeta de presentación para cargarlo en la herramienta Diseñador.
Por defecto, el diseño debe contener una sola vista de componentes en forma de la TextView mostrando el
mensaje "Hola Mundo!". Seleccionar este componente y retírela pulsando la tecla Suprimir del teclado. Desde
dentro de la categoría de paleta Widgets, arrastre un objeto de vista de Button en el centro de la vista de la
pantalla. Tenga en cuenta que verdes líneas de trazos horizontales y verticales parecen indicar los ejes
centrales de la pantalla. Una vez centrado, suelte el botón del ratón para colocar la vista en su posición. Haga
clic y arrastre una vista Sólo texto de la sección de campos de texto de la paleta y posicionarlo para que
aparezca encima del botón como se ilustra en la Figura 16-2:
Figura 16-2
Haga clic en el icono de la bombilla para visualizar el menú de sugerencias y hacer clic en el mensaje que dice:
"Este campo de texto no especifica un InputType o una indirecta" y seleccione Texto como tipo de entrada en el
conjunto de atributos de diálogo. Haga clic en Aceptar para cerrar el diálogo y establecer el atributo.
Edición de propiedades de la vista

Una vez que un objeto de vista ha sido colocado en la interfaz de usuario, las propiedades de este punto de
vista también se pueden modificar desde dentro de la herramienta del diseñador. En el primer caso, la anchura
del objeto EditarTexto puede ser insuficiente para permitir que el usuario introduzca texto. Para cambiar esto,
seleccione el objeto EditarTexto y busque y seleccione la propiedad de ancho en el panel Propiedades. En el
campo Valor, escriba un valor para el ancho deseado del campo. El valor debe incluir una unidad de medida de
la siguiente lista:
 en - Pulgadas
 mm - Milímetros
 pt - Puntos (1/72 de pulgada)
 dp - independiente de la densidad de píxeles. Una unidad abstracta de medida basado en la densidad
física de la pantalla del dispositivo con relación a una línea de base 160dpi pantalla.
 sp - independiente de la escala píxeles. Similar a dp pero a escala basada en la preferencia de fuente
del usuario.
 px - píxeles de la pantalla real. El uso no se recomienda ya que diferentes pantallas tendrán diferentes
píxeles por pulgada. Utilice dp con preferencia a esta unidad.
A los efectos de este ejemplo, utilizaremos densidad píxeles independientes como nuestra unidad de medida,
por lo que entrar en 350dp en el cuadro de diálogo y haga clic en el botón Aceptar. La anchura de la vista
EditarTexto debe cambiar en consecuencia.
A continuación, haga doble clic en el botón de vista y en el panel resultante, cambie la propiedad de texto de
"Nuevo botón" a "Pulse Me". Haga clic en el icono de la bombilla seguido del mensaje I18N para mostrar el
diálogo Extract Resource. Nombre del button_string recurso y haga clic en Aceptar para crear un recurso de
cadena para el botón.
El diseño de la interfaz de usuario muy sencilla ha finalizado. El diseño de un diseño de la interfaz de usuario
más complejo es una continuación de los pasos descritos anteriormente. Basta con arrastrar y soltar vistas a la
pantalla, la posición y las propiedades que figuran como sea necesario y diseños nido según sea necesario.
Todo lo que queda es probar que la aplicación se ejecuta. Haga clic en el botón de ejecución en la barra de
herramientas de la ventana principal. Seleccione el simulador o un dispositivo Android física y esperar a que la
aplicación se inicie. Suponiendo que la ausencia de errores, la aplicación y la actividad deben poner en marcha
y aparecerá exactamente como fue diseñado con la función Designer.
Creación manual de un diseño XML

Si bien el diseño de layouts utilizando la herramienta de diseño de mejora en gran medida la productividad,
todavía es posible crear diseños XML editando manualmente el código XML. La estructura de un archivo de
diseño XML en realidad es bastante sencillo y sigue el enfoque jerárquico de la vista de árbol. La primera línea
de un archivo de recursos XML debe incluir idealmente la siguiente declaración estándar:
Esta declaración debe ser seguido por el elemento raíz de la disposición, por lo general una visión recipiente tal
como un controlador de distribución. Esto está representado por las dos etiquetas de apertura y cierre y las
propiedades que hay que establecer en la vista. La siguiente XML, por ejemplo, declara una vista RelativeLayout
como el elemento raíz y establece las propiedades match_parent de manera que llene todo el espacio
disponible de la pantalla del dispositivo con el acolchado en cada lado de densidad 64 píxeles independientes:
<RelativeLayout
xmlns: android = "http://schemas.android.com/apk/res/android"
android: paddingLeft = "64DP"
android: paddingRight = "64DP"
android: paddingTop = "64DP"
android: paddingBottom = "64DP"
herramientas: contexto =
"Com.ebookfrenzy.layoutsample.layoutsample.LayoutSampleActivity">
</ RelativeLayout>
Cualquier niño que hay que añadir a los padres RelativeLayout deben estar anidadas dentro de las etiquetas de
apertura y cierre. En el siguiente ejemplo, un botón y un campo EditarTexto se han añadido como hijos de la
vista RelativeLayout:
<RelativeLayout
android: paddingLeft = "64DP"
android: paddingRight = "64DP"
android: paddingTop = "64DP"
android: paddingBottom = "64DP"
"Com.ebookfrenzy.layoutsample.layoutsample.LayoutSampleActivity">
<Botón
android: text = "@ string / button_string"
android: id = "@ + / Identificación del botón"
<EditarTexto
android: id = "@ + / Identificación del EDITTEXT"
android: layout_above = "@ + / Identificación del botón"
android: layout_marginBottom = "51dp"
android: InputType = "text"
android: width = "350dp" />
</ RelativeLayout>
También tenga en cuenta que los dos puntos de vista del niño tienen una serie de propiedades declaradas. En
el caso de la Vista de botones, se ha asignado "botón" Identificación y configurado para mostrar el texto que se
representa mediante un recurso de cadena denominada button_string. Además, se ha centrado vertical y
horizontalmente dentro de la altura vista padre y wrap_content y propiedades de ancho han sido declaradas de
modo que se dimensiona el botón para acomodar el contenido (en este caso el texto que se muestra en el
botón).
La vista EditarTexto, por otro lado, tiene una anchura declarada como 350dp, se centra horizontalmente dentro
de la matriz y 51dp encima de la vista botón colocado.
Este archivo XML es, por supuesto, el diseño que se creó utilizando la herramienta de diseño en este
capítulo. Al escribir XML manualmente en lugar de utilizar la herramienta de diseño en el modo de diseño es una
cuestión de preferencia personal. Hay, sin embargo, las ventajas de utilizar el modo de diseño.En primer lugar,
el modo de diseño generalmente será más rápido ya que se evita la necesidad de escribir líneas de
XML. Además, el modo de diseño evita la necesidad de aprender las complejidades de los diferentes valores de
las propiedades de las clases de vista del SDK de Android. En lugar de hacer referencia continuamente a la
documentación de Android para encontrar las palabras clave y los valores correctos, la mayoría de las
propiedades se pueden localizar consultando el panel Propiedades.
Todas las ventajas del modo de diseño a un lado, es importante tener en cuenta que los dos enfoques para el
diseño de interfaces de usuario son de ninguna manera mutuamente excluyentes. Como un desarrollador de
aplicaciones, es muy probable que el resultado final será la creación de interfaces de usuario en el modo de
diseño durante la realización de ajuste y de la disposición retoques del diseño editando directamente los
recursos XML generados. Ambos puntos de vista del diseño de la interfaz son, después de todo, un solo clic del
ratón aparte dentro del entorno Android estudio por lo que es fácil cambiar un lado a otro según sea
necesario. De hecho, un consejo útil para recordar es que la selección de un punto de vista en el diseño de la
pantalla y pulsar la combinación de teclas Ctrl-B saltará automáticamente y poner de relieve el XML para esa
vista en el archivo de recursos.
Uso del Visor Jerarquía

Una herramienta útil para inspeccionar de cerca la jerarquía de la vista de una actividad es el visor de la
Jerarquía. El propósito principal de la herramienta es proporcionar una descripción detallada de todo el árbol de
vista de las actividades dentro de las aplicaciones actualmente en ejecución y proporcionar alguna información
sobre el rendimiento de la representación de diseño.
El espectador jerarquía sólo se puede utilizar para inspeccionar las aplicaciones que se están ejecutando, ya
sea dentro de un emulador de Android, o en un dispositivo que ejecuta una versión de desarrollo de
Android. Para ejecutar la herramienta en la aplicación LayoutSample creado en este capítulo, iniciar la
aplicación en un emulador de dispositivo virtual de Android y esperar hasta que se haya cargado y es visible en
la pantalla del emulador. Una vez en funcionamiento, seleccione Herramientas -> Android -> Dispositivo Android
opción de menú Monitor. En la ventana DDMS, seleccione la Ventana -> Abrir perspectiva ... opción de menú y
seleccione Jerarquía Vista desde el cuadro de diálogo resultante antes de hacer clic en el botón Aceptar.
Cuando aparezca el visor de la Jerarquía, que consistirá en una serie de diferentes paneles. El panel de la
izquierda, que se ilustra en la Figura 16 315 3, enumera todas las ventanas activas actualmente en el dispositivo
o emulador, como la barra de navegación, barra de estado y el lanzador. La ventana que aparece en negrita es
la ventana actual en primer plano, lo que debería, en este caso, ser LayoutSampleActivity.
Figura 16-3
Selección de la ventana muestra el diseño hará que la jerarquía para cargar en el panel de vista de árbol como
se muestra en la Figura 16-4 (tenga en cuenta que puede haber un pequeño retraso entre la selección de la
ventana y el diagrama de jerarquía que aparece):
Figura 16-4
Si bien es posible hacer zoom dentro y fuera de la vista de árbol utilizando la escala en la parte inferior del panel
o haciendo girar la rueda del ratón, en la mayoría de los casos, el árbol será demasiado grande como para ver
por completo dentro del panel de vista de árbol. Para mover la ventana de vista alrededor del árbol simplemente
haga clic y arrastre en el panel de vista de árbol, o mover la lente dentro del panel de Vista del árbol (Figura 16-
5):
Figura 16-5
Al revisar la vista de árbol, tener en cuenta que se mostrarán algunos puntos de vista, además de las incluidas
en el diseño de actividades. Estos son los puntos de vista y diseños que, por ejemplo, muestran la barra de
acción en la parte superior de la pantalla y proporcionan un área para la actividad que se mostrará.
Selección de un nodo en la vista de árbol hará que el elemento correspondiente en la representación de interfaz
de usuario que se resalta en rojo en la vista de diseño. En la figura 16-6 la vista RelativeLayout está
seleccionado actualmente:
Figura 16-6
Del mismo modo, la selección de vistas desde la vista de diseño hará que el nodo correspondiente en la vista de
árbol para resaltar y mover a la vista.
Más información sobre un punto de vista puede ser obtenida mediante la selección del nodo dentro de la vista
de árbol. Un panel entonces emergente junto al nodo y puede ser destituido mediante la realización de un clic
derecho en el nodo. Al hacer doble clic en un nodo mostrará un cuadro de diálogo que contiene una
representación de cómo aparece la vista dentro de la interfaz de usuario de la aplicación. Figura 16-7, por
ejemplo, muestra el botón de la aplicación LayoutSample:
Figura 16-7
Las opciones también están disponibles dentro de la herramienta para llevar a cabo tareas como la invalidación
de una vista de diseño seleccionado (por lo tanto lo que obligó a volver a dibujar) y para salvar la vista de árbol
como una imagen PNG file.The espectador jerarquía también se puede utilizar para mostrar información sobre la
velocidad con la que el niño vistas de un nodo seleccionado se prestan cuando se crea la interfaz de
usuario. Para mostrar esta información de rendimiento, seleccione el nodo de actuar como la vista de la raíz y
haga clic en el botón de la barra indica en la figura 16-8. Cuando se activa, los puntos de colores dentro de los
nodos indican el rendimiento en cada categoría (medida, diseño y dibujar) con rojo indicando un rendimiento
más lento para la vista en relación con otros puntos de vista en la actividad. Vistas de contenedores con mayor
número de visitas de niños pueden mostrar el estado rojo, simplemente porque el punto de vista tiene que
esperar a que cada niño va a representar. Esto no es necesariamente una indicación de un problema de
rendimiento con esa opinión.
Figura 16-8
Resumen
La herramienta Android Studio Designer proporciona un método visual intuitiva para el diseño de interfaces de
usuario. El uso de un paradigma de arrastrar y soltar en combinación con un conjunto de editores de
propiedades, la herramienta proporciona considerables beneficios de productividad a los desarrolladores de
aplicaciones.
Diseños de interfaz de usuario también pueden ser implementadas por escribir manualmente los archivos de
recursos de diseño XML, cuyo formato está bien estructurado y de fácil comprensión.
El hecho de que la herramienta Designer genera archivos de recursos XML significa que estos dos enfoques de
diseño de la interfaz se pueden combinar para proporcionar una "mejor de ambos mundos" enfoque para el
desarrollo de interfaces de usuario.
Por último, una descripción detallada de la vista de árbol para una actividad y una indicación de la actuación de
cada vista dentro de esa actividad se pueden obtener utilizando la herramienta Visor de Jerarquía.
16 Creación de una interfaz de usuario de Android en el
Código Java utilizando Android Estudio
Hasta este punto en el libro, todas las tareas de diseño de interfaz de usuario se han realizado utilizando la
herramienta Android Studio Designer, ya sea en texto o en modo de diseño. Una alternativa a la escritura de
archivos de recursos XML o el uso de Android Studio Designer es escribir código Java para crear directamente,
configurar y manipular los objetos de vista que componen la interfaz de usuario de una actividad Android. En el
contexto de este capítulo, vamos a explorar algunas de las ventajas y desventajas de escribir código Java para
crear una interfaz de usuario antes de describir algunos de los conceptos clave, como las propiedades de vista,
los parámetros de diseño y las reglas. Por último, un proyecto de ejemplo se creará y se utiliza para demostrar
algunos de los pasos típicos en este enfoque de la creación de interfaces de usuario de Android.
ódigo Java vs. XML archivos de diseño

Hay un número de ventajas clave para usar archivos de recursos XML para diseñar una interfaz de usuario en
lugar de escribir código Java. De hecho, Google va a longitudes considerables en la documentación Android
para ensalzar las virtudes de los recursos XML a través de código Java. Como se discutió en el capítulo anterior,
una ventaja clave para el enfoque XML incluye la capacidad de utilizar la herramienta Diseñador Android Studio,
que, en sí, genera recursos XML. Una segunda ventaja es que una vez que se ha creado una aplicación, los
cambios en las pantallas de la interfaz de usuario se pueden hacer simplemente modificando el archivo XML,
evitando así la necesidad de volver a compilar la aplicación. Además, incluso cuando la mano escribiendo
diseños XML, es posible obtener información inmediata sobre la apariencia de la interfaz de usuario mediante la
función de vista previa de la herramienta Android Studio Designer. Con el fin de probar la apariencia de un Java
creado interfaz de usuario, el promotor, inevitablemente, ciclo repetidamente a través de un bucle de escribir
código, compilación y pruebas con el fin de completar el trabajo de diseño.
En términos de los puntos fuertes del enfoque de Java codificación para la creación de diseño, quizás la ventaja
más significativa que Java tiene más archivos de recursos XML entra en juego cuando se trata de las interfaces
de usuario dinámicas. Archivos de recursos XML son inherentemente más útil en la definición de los diseños
estáticos, en otras palabras, los diseños que son poco probable que cambie significativamente de una
invocación de una actividad a otra. Código Java, por otro lado, es ideal para crear interfaces de usuario
dinámicamente en tiempo de ejecución. Esto es particularmente útil en situaciones en las que la interfaz de
usuario puede aparecer de forma diferente cada vez que se ejecuta la actividad sujeta a factores externos.
El conocimiento de trabajar con componentes de interfaz de usuario en código Java también puede ser útil
cuando los cambios dinámicos a un diseño basado en los recursos XML estática se deben realizar en tiempo
real como la actividad está en marcha.
Por último, algunos desarrolladores simplemente prefieren escribir código Java que utilizar herramientas de
diseño y XML, independientemente de las ventajas ofrecidas por los últimos enfoques.
Creación de vistas
Según lo establecido anteriormente, el SDK de Android incluye una caja de herramientas de vista clases
diseñadas para satisfacer la mayoría de las necesidades básicas de diseño de interfaz de usuario. La creación
de una vista en Java es simplemente una cuestión de crear instancias de estas clases, pasando a través de
como argumento una referencia a la actividad con la que este punto de vista es que se asocia.
La primera vista (normalmente una vista contenedor al que vistas adicionales del niño pueden ser añadidos) se
muestra al usuario a través de una llamada al método setContentView () de la actividad. Vistas adicionales
pueden ser agregados a la vista de la raíz a través de llamadas a método del objeto addView ().
Cuando se trabaja con código Java para manipular opiniones contenidas en archivos de recursos de diseño de
XML, es necesario para obtener el identificador de la vista. La misma regla vale para las vistas creadas en
Java. Como tal, es necesario asignar una identificación a cualquier vista para la que se necesitarán
determinados tipos de acceso en posteriores código Java. Esto se logra a través de una llamada al método setId
() del objeto de vista de que se trate. En el código más tarde, el ID de un punto de vista puede ser obtenido a
través de una llamada posterior al método del objeto getId ().
Propiedades y parámetros de diseño

Cada clase de vista ha asociado a él una serie de propiedades. Estos valores de propiedades se establecen
directamente en las instancias de vista y generalmente definen cómo aparecerá el objeto de vista o
comportarse. Ejemplos de propiedades son el texto que aparece en un objeto Button, o el color de fondo de una
vista RelativeLayout. Cada clase de vista dentro del SDK de Android cuenta con un conjunto predefinido de
métodos que permiten al usuario configurar y obtener estos valores de propiedad. La clase Button, por ejemplo,
tiene un método setText () que se puede llamar desde el código de Java para establecer el texto que aparece en
el botón para un valor de cadena específica. El color de fondo de un objeto RelativeLayout, por el contrario, se
puede configurar con una llamada al método del objeto setBackgroundColor ().
Si bien la configuración de propiedades son internos para ver objetos y dictar cómo aparece una vista y se
comporta, Parámetros de diseño se utilizan para controlar la forma en una vista aparece en relación con su
punto de vista de los padres y otras visitas de hermanos. Parámetros de diseño no se fijan en la misma manera
como propiedades, sino más bien almacenan en una instancia de ViewGroup.LayoutParams (o una subclase de
los mismos) que luego se pasa o bien a través de como argumento cuando se añade la vista a la vista de los
padres, o asignado a la opinión de los niños a través de una llamada a setLayoutParams de la vista () método.
Un objeto LayoutParams para una vista se crea normalmente declarando cómo la visión debe dimensionarse en
relación con la vista padre (es decir, si debe llenar la matriz o ser dimensionado para ajustar el contenido que
necesita para mostrar). Una vez que el objeto existe LayoutParams, normas adicionales, tales como si la vista
debe estar alineado con otro punto de vista, se pueden agregar mediante llamadas al método addRule () del
objeto LayoutParams.
Hay subclases de ViewGroup.LayoutParams para cada uno de los tipos de diseño
(AbsoluteLayout.LayoutParams, RelativeLayout.LayoutParams y así sucesivamente).
Después de haber cubierto la teoría de la creación de interfaces de usuario desde el código de Java, el resto de
este capítulo se va a trabajar metódicamente a través de la creación de una aplicación de ejemplo con el
objetivo de poner en práctica esta teoría.
Crear el proyecto de ejemplo en Android Estudio

Lanzamiento Android Studio y seleccionar el nuevo proyecto ... opción de la lista de inicio rápido en la pantalla
de bienvenida. Si los proyectos existentes ya están abiertos, cierre primero que usan el Archivo -> Cerrar opción
de menú.
En el nuevo cuadro de diálogo de configuración del proyecto, entrando JavaLayout en el campo Nombre de la
aplicación y ebookfrenzy.com como el dominio de la empresa establecer antes de hacer clic en el botón
Siguiente.
actividad en blanco denominada JavaLayoutActivity con una disposición correspondiente llamado
activity_java_layout.
Una vez que el proyecto ha sido creado, el archivo JavaLayoutActivity.java debe cargar automáticamente en el
panel de edición. Como hemos llegado a esperar, Android Studio ha creado una actividad de molde y se
reemplaza el método onCreate (), proporcionando un lugar ideal para el código Java que se añade a crear una
interfaz de usuario.
Adición Vistas a una actividad
El método onCreate () está diseñado para utilizar un archivo de diseño de recursos para la interfaz de
usuario. Comience, por lo tanto, mediante la supresión de esta línea desde el método:
@ Override
setContentView (R.layout.activity_java_layout);
}
La siguiente modificación en el método onCreate () es escribir algo de código Java para agregar un objeto
RelativeLayout con una sola vista Botón niño a la actividad. Esto implica la creación de nuevas instancias de las
clases RelativeLayout y Button. Necesita entonces el botón Vista que se añade como un niño a la vista
RelativeLayout que, a su vez, se muestra a través de una llamada al método setContentView () de la instancia
de actividad:
com.ebookfrenzy.javalayout paquete;
android.widget.Button importación;
android.widget.RelativeLayout importación;
public class JavaLayoutActivity extiende ActionBarActivity {
@ Override
Botón myButton = new Button (this);
RelativeLayout myLayout = new RelativeLayout (this);
myLayout.addView (myButton);
setContentView (myLayout);
}
.
.
.
}
Una vez que se han hecho las adiciones anteriores, compilar y ejecutar la aplicación (ya sea en un dispositivo
físico o un emulador). Una vez puesto en marcha, el resultado visible será un botón que no contiene ningún
texto que aparece en la esquina superior izquierda de la vista RelativeLayout como se muestra en la Figura 17-
1:
Figura 17-1
Configuración de propiedades de la vista
A los efectos de este ejercicio, necesitamos que el fondo de la vista RelativeLayout a ser azul y la vista del botón
para mostrar el texto que lee "prensa me".Ambas tareas se puede lograr mediante el establecimiento de
propiedades en las vistas en el código Java como se indica en el siguiente fragmento de código:
android.graphics.Color importación;
@ Override
myButton.setText ("Presione Me");
myButton.setBackgroundColor (Color.YELLOW);

myLayout.setBackgroundColor (Color.BLUE);
myLayout.addView (myButton);
}
.
.
.
}
Cuando la aplicación está ahora compila y ejecuta, la distribución reflejará la configuración de propiedades de
manera que el diseño aparecerá con un fondo azul y el botón se mostrará el texto asignado en un fondo
amarillo.
Agregar parámetros y reglas de diseño

Por defecto, la vista RelativeLayout ha colocado a la vista botón en la esquina superior izquierda de la
pantalla. Con el fin de instruir a la vista de diseño para colocar el botón en una ubicación diferente, en este caso
centrado tanto horizontal como verticalmente, será necesario crear un objeto LayoutParams e inicializar con los
valores apropiados.
Por lo general, una nueva instancia LayoutParams se crea al pasar por los valores de altura y anchura para la
vista. Estos valores se deben establecer en MATCH_PARENT, WRAP_CONTENT o específicos valores de
tamaño. El ajuste MATCH_PARENT instruye la disposición de los padres para ampliar la vista del niño para que
coincida con el tamaño de la matriz. WRAP_CONTENT, por otro lado, instruye a los padres con el tamaño de la
vista del niño de modo que es sólo lo suficientemente grande para mostrar cualquier contenido puede ser
configurado para mostrar al usuario.
El código para crear un objeto LayoutParams para nuestro botón con el siguiente texto:
RelativeLayout.LayoutParams buttonParams =
nuevos RelativeLayout.LayoutParams (
RelativeLayout.LayoutParams.WRAP_CONTENT,
RelativeLayout.LayoutParams.WRAP_CONTENT);
El código anterior crea un nuevo RelativeLayout LayoutParams objetos nombrados buttonParams y establece la
altura y la anchura tal que el botón sólo será lo suficientemente grande para mostrar la "prensa me" texto
configurado previamente a través de la configuración de la propiedad.
Ahora que el objeto LayoutParams ha sido creado, el siguiente paso es añadir algunas reglas adicionales a los
parámetros para instruir a los padres disposición para centrar el botón vertical y horizontalmente. Esto se logra
mediante una llamada al método addRule () del objeto buttonParams, pasando por los valores apropiados como
argumentos:
buttonParams.addRule (RelativeLayout.CENTER_HORIZONTAL);
buttonParams.addRule (RelativeLayout.CENTER_VERTICAL);
Simplemente creando un objeto nuevo LayoutParams y configuración sólo es útil si ese objeto se le asigna a la
vista de los niños. Una forma de lograr esto es pasar los LayoutParams objeto a través como argumento cuando
se añade el punto de vista del niño a los padres:
myLayout.addView (myButton, buttonParams);
Alternativamente, los parámetros se pueden asignar al niño a través de una llamada al método de la vista
setLayoutParams ():
myButton.setLayoutParams (buttonParams);
La combinación de estos resultados juntos en un método onCreate modificado () que dice lo siguiente:
@ Override
myButton.setText ("Press me");


}
Después de haber hecho los cambios mencionados, compilar y ejecutar la aplicación, una vez más, esta vez
señalando que el botón se centra ahora en la vista RelativeLayout como se ilustra en la Figura 17 216 2:
Figura 17-2
Con el fin de obtener una comprensión más clara de los ajustes de altura y parámetros diseño de ancho,
modificar temporalmente el código de creación buttonParams de la siguiente manera, a continuación, volver a
compilar y ejecutar la aplicación:
RelativeLayout.LayoutParams.MATCH_PARENT,
RelativeLayout.LayoutParams.MATCH_PARENT);
Con la altura y parámetros de ancho establecidos para MATCH_PARENT, el botón está dimensionada para que
coincida con la opinión de los padres y, en consecuencia llena toda la pantalla.
Antes de continuar, revertir la configuración de alto y ancho para WRAP_CONTENT.
Usando Ver IDs

Hasta ahora, en este tutorial no ha sido necesario el uso de identificadores de vista. Con el fin de demostrar el
uso de identificadores en el código de Java, el ejemplo ahora se extenderá a añadir otro punto de vista en forma
de una vista EditarTexto que será configurado para ser alineado 80 píxeles por encima del botón existente y
centrado horizontalmente. Las siguientes modificaciones de código añaden la nueva vista a la actividad y luego
establecer los ID de 1 y 2 en el botón y vistas EditText respectivamente. Parámetros de diseño se crean a
continuación para la vista EditarTexto para que quede alineado con el botón (nota de la llamada a getId () en el
botón para obtener el ID de vista) y centrado horizontalmente dentro del diseño. Por último, la propiedad
márgenes del campo EditarTexto está configurado para establecer el margen inferior a 80 píxeles antes de
añadir la nueva vista de la disposición de los padres:

@ Override

EditarTexto myEditText = new EditarTexto (this);
myButton.setId (1);
myEditText.setId (2);
RelativeLayout.LayoutParams textParams =
textParams.addRule (RelativeLayout.ABOVE, myButton.getId ());

textParams.addRule (RelativeLayout.CENTER_HORIZONTAL);
textParams.setMargins (0, 0, 0, 80);

myLayout.addView (myEditText, textParams);
}
.
.
.
}
Una prueba de funcionamiento de la aplicación debe mostrar el campo EditarTexto centrado sobre el botón con
un margen de 80 píxeles.
Píxeles Independientes Densidad Conversión (dp) a píxeles (px)

La tarea final en este ejercicio es para establecer el ancho de la vista EditarTexto a 200dp. Como se indica en el
capítulo titulado El diseño de una interfaz de usuario de Android utilizando la herramienta de diseño gráfico, al
establecer medidas y posiciones en los diseños de interfaz de usuario, es mejor utilizar píxeles de densidad
independientes (dp) en lugar de píxeles (px). Cuando el margen se establece en el apartado anterior, el valor fue
declarado en píxeles en lugar de dp. La razón de esto era que tales llamadas a métodos sólo aceptan valores de
píxeles. Con el fin de establecer una posición usando dp, por lo tanto, es necesario para convertir un valor dp a
un valor px en tiempo de ejecución, teniendo en cuenta la densidad de la pantalla del dispositivo. En fin, por lo
tanto, para ajustar el ancho de la vista EditarTexto a 350dp, el siguiente código debe ser añadido al método
onCreate ():
android.app.Activity importación;
android.content.res.Resources de importación;
android.util.TypedValue importación;
@ Override
public void onCreate (Bundle savedInstanceState) {

EditarTexto myEditText = new EditarTexto (this);
myButton.setId (1);
myEditText.setId (2);

RelativeLayout.LayoutParams textParams =
textParams.addRule (RelativeLayout.ABOVE, myButton.getId ());

textParams.addRule (RelativeLayout.CENTER_HORIZONTAL);
textParams.setMargins (0, 0, 0, 80);
Recursos r = getResources ();

int px = (int) TypedValue.applyDimension (
TypedValue.COMPLEX_UNIT_DIP, 200,
r.getDisplayMetrics ());
myEditText.setWidth (px);

myLayout.addView (myEditText, textParams);
}
}
Compile y ejecute la aplicación una vez más y tenga en cuenta que el ancho de la vista EditarTexto ha
cambiado como se ilustra en la Figura 17-3:
Figura 17-3
Resumen
Como alternativa a la escritura de archivos de recursos de diseño XML o utilizando la herramienta Android
Studio Designer, interfaces de usuario de Android también se pueden crear de forma dinámica en código
Java. Creación de diseños en código Java consiste en crear instancias de clases de vista y configuración de
propiedades de los objetos para definir la apariencia y el comportamiento requerido.
¿Cómo se coloca un punto de vista y de tamaño con respecto a la vista padre y cualquier vistas hermano se
define mediante los parámetros de diseño, que se almacenan en objetos LayoutParams. Una vez que un objeto
LayoutParams ha sido creado e inicializado con la altura y el ancho de las opciones de comportamiento,
entonces se pueden añadir reglas adicionales para configurar los parámetros más.
La actividad ejemplo creado en este capítulo ha sido, por supuesto, creado de la misma interfaz de usuario (el
cambio en el color de fondo a pesar) como el creado en el capítulo anterior utilizando las herramientas y los
recursos XML gráfica de diseño. Por lo menos, este capítulo debería haber proporcionado una apreciación del
nivel al que la herramienta Diseñador y XML recursos Android Studio protegen el promotor de muchas de las
complejidades de la creación de diseños de interfaz de usuario de Android.
Hay, sin embargo, casos en los que tiene sentido para crear una interfaz de usuario en Java. Este enfoque es
más útil, por ejemplo, cuando la creación de diseños de interfaz de usuario dinámicas.
17 Uso del Administrador de Android GridLayout en Android

Studio Designer
Un controlador de distribución útil que fue presentado como parte del SDK de Android 4.0 es la clase gerente
GridLayout. Como su nombre indica, esta clase permite vistas niño para ser dispuestos en un diseño de
cuadrícula. Hay un número de maneras de implementar el GridLayout dentro de la interfaz de usuario de una
aplicación Android, incluso mediante el uso de los recursos de diseño y código Java. Quizás el método más
sencillo, sin embargo, es hacer uso de algunas características específicas GridLayout integradas en la
herramienta Android Studio Designer.
En este capítulo se presentarán los conceptos básicos de la clase GridLayout antes de explorar la creación de
una interfaz de usuario basada en GridLayout usando Android Studio Designer. Creando directamente
GridLayout diseños de interfaz de usuario que utilizan los recursos de diseño de XML como una alternativa al
uso de la herramienta Diseñador serán cubiertos en el siguiente capítulo, titulado Trabajar con el GridLayout
Android usando XML Recursos de diseño.
ntroducción de las Clases Android GridLayout y el Espacio

El propósito de la GridLayout es permitir vistas niño para ser colocados en una disposición en cuadrícula. El
GridLayout consiste esencialmente en un número de líneas de cuadrícula horizontales y verticales invisibles que
sirven para dividir la vista de diseño en una serie de filas y columnas, con cada fila y columna de intersección
formando una célula que puede a su vez, contener uno o más puntos de vista. Las líneas de la cuadrícula se
denominan índices, que se numeran a partir del 0 para la línea en la vanguardia del diseño. Fila y columna de
numeración también comienza en 0 a partir de la esquina superior izquierda de la cuadrícula.
El posicionamiento de una vista dentro de una célula se puede definir mediante el uso de la configuración de la
gravedad sobre dicho punto de vista del niño. La gravedad de una vista niño puede, por ejemplo, ser
configurado de tal manera que la vista aparece centrada, llena toda la célula o se coloca en una esquina
específica de la célula dentro de la que reside.
Además, una vista hijo de un padre GridLayout también puede estar configurado para abarcar varias filas y
columnas a través del uso de las propiedades rowspan y ColumnSpan del niño. Otra clase útil que puede ser
utilizado en conjunción con el GridLayout es la clase de espacio. Esta es una clase muy simple, con el único
propósito de los cuales es la creación de lagunas dentro de diseños. En el caso de la clase GridLayout, una
vista del espacio se puede colocar en cualquier célula como cualquier otro objeto de vista.
Además de utilizar la clase de espacio para crear huecos, el espacio alrededor de puntos de vista en las células
puede ser controlado a través de las diversas propiedades de diseño de margen (superior, inferior, izquierda y
derecha) de cada niño.
El GridLayout Ejemplo
Dada la naturaleza visual tanto de la clase GridLayout y la herramienta Android Studio Designer, la mejor
manera de obtener un nivel de familiaridad con los conceptos involucrados es trabajar a través de un ejemplo. El
resto de este capítulo, por lo tanto, va a crear una aplicación de ejemplo que muestra algunas de las
características clave de la clase GridLayout en el contexto de la herramienta Diseñador.
Crear el proyecto GridLayout

Comience con el lanzamiento de Android Studio y crear un nuevo proyecto. En el cuadro de diálogo Nuevo
proyecto, entrando GridLAyoutSample en el campo Nombre de la aplicación y ebookfrenzy.com como el ajuste
de dominio de la empresa antes de hacer clic en el botón Siguiente.
actividad en blanco denominada GridLayoutSampleActivity con una disposición correspondiente llamado
activity_grid_layout_sample.
Haga clic en el botón Finalizar para iniciar el proceso de creación del proyecto.
Crear el GridLayout Instancia

En la creación del nuevo proyecto, Android Studio pre-cargar el archivo GridLayoutSampleActivity.java en una
pestaña editor. En este caso, lo que realmente necesitamos estar trabajando en el archivo de recursos de
diseño activity_grid_layout_sample.xml. Dentro de la ventana de herramientas del proyecto, vaya a la
GridLayoutSample -> aplicación -> src -> principal -> res -> carpeta de presentación y haga doble clic en el
archivo para cargarlo en el Diseñador Android Studio. Con el diseño de muestra, seleccione el Hola
Mundo! Vista de texto objeto y pulse el teclado tecla Supr para eliminarlo de la disposición.
El diseño de la disposición actualmente consiste únicamente de un gerente RelativeLayout a la que ahora
podemos añadir una instancia del gestor de GridLayout. Desde la sección Diseños de la paleta de Designer,
seleccione un administrador de GridLayout y arrastrar y soltar en la pantalla del dispositivo. El diseño debe llenar
la pantalla con márgenes de relleno en cada lado como se muestra en la Figura 18-1:
Figura 18-1
A los efectos de este tutorial, el GridLayout sólo está obligado a ser lo suficientemente grande para dar cabida a
las opiniones del niño en él contenidas. Como tal, los parámetros de altura y anchura de la vista GridLayout
necesitan ser cambiados de fill_parent a wrap_content. Una manera de hacer este cambio es localizar las
propiedades en el panel Propiedades de la herramienta Diseñador. Una opción más rápida es seleccionar la
instancia GridLayout y utilice los dos botones en la barra de herramientas Diseñador. Establezca la propiedad
anchura haciendo clic en el botón de ancho de la disposición como se destaca en la Figura 18-2:
Figura 18-2
Después de haber establecido la propiedad width de wrap_content, haga clic en el botón de la barra adyacente,
para seleccionar de manera similar la propiedad layout_height. Estos ajustes tendrán el efecto de reducir la
disposición a una pequeña plaza listo para dar cabida a algunos puntos de vista del niño.
Adición Vistas a células GridLayout

Para colocar objetos de vista en las células de un GridLayout, simplemente haga clic en la vista deseada en la
paleta y arrástrelo a la instancia GridLayout en el diseño de la lona pantalla del dispositivo. Como la vista pasa
sobre el GridLayout, la información aparecerá indicando la colocación de la vista si se cae en ese
punto. Comience haciendo clic y arrastrando una vista Botón de la paleta a la esquina superior derecha de la
GridLayout como se ilustra en la Figura 18-3:
Figura 18-3
Como es evidente a partir del mensaje mostrado por la herramienta, la liberación de la vista en este punto lo
colocará en la celda referenciada por las coordenadas de 0,0.
Suelte la vista en este punto y observe que el botón se coloca en la célula como se muestra en la Figura 18-4:
Figura 18-4
Tenga en cuenta también que las barras verdes han aparecido en los márgenes en los lados superior y derecho
de la zona principal de Designer. Estas barras representan las filas y columnas presentes en el GridLayout
(actualmente el diseño tiene una fila y una columna). Como es evidente de la Figura 18-4 arriba, sin embargo,
estas barras no se alinean con el botón contenida en el GridLayout. Esto es debido a que el diseño de la
pantalla del dispositivo esté visible el marco gráfico dispositivo que está empujando el diseño fuera de alineación
con las barras verdes. Para resolver este problema, seleccione la opción de menú de configuración en la barra
de herramientas de diseño (representado por el icono de engranaje reductor) y apague los marcos de dispositivo
incluye la opción (disponible si). Sin el bastidor del dispositivo visibles las barras de fila y columna se alinearán
con el controlador de distribución, como se muestra en la Figura 18-5:
Figura 18-5
Repetir los pasos anteriores para colocar un segundo botón en el GridLayout de modo que se posiciona en la
fila cero y después de la columna 0 tal que aparece inmediatamente a la derecha de la primera botón.
Arrastre un tercer punto de vista del botón a una posición a la izquierda de la primera vista del botón hasta que
el mensaje que se muestra en la Figura 18-6 parece ofrecer la opción de cambiar la columna 0 derecha e inserte
la nueva vista en la célula en 0,0:
Figura 18-6
Cuando la vista se coloca en esta posición, las columnas existentes se desplazarán un lugar hacia la derecha,
se insertará una nueva columna en el borde izquierdo de la GridLayout y el nuevo botón colocado en la célula.
Siguiendo la misma secuencia de pasos, añadir una vista botón en la segunda fila de la parrilla colocada
después de la fila 0 en la columna 0 de modo que el diseño se asemeja a la de la Figura 18-7:
Figura 18-7
Mover y eliminar filas y columnas

Tenga en cuenta que a medida que se han añadido filas y columnas adicionales, barras verdes se han
presentado otros los márgenes para representar las filas y columnas. Estas barras no son meramente
informativos. Filas y columnas enteras se pueden mover haciendo clic y arrastrando el bloque verde que
corresponde a una nueva posición dentro del mismo eje. Haga clic en un bloque y seleccionando Eliminar en el
menú resultante quitará toda la fila o columna de la GridLayout.
La implementación de la fila de la célula y Spanning Columna

Para la siguiente fase de este tutorial, dos de los puntos de vista del botón será modificada para abarcar varias
células. Para empezar, el botón de la derecha mano en la fila superior será modificada para abarcar ambas
filas. Para ello, seleccione el botón de la mesa y localizar el diseño: la propiedad rowspan enumerados en el
panel Propiedades. Una vez localizado, introduzca el valor de 2 en el campo como se destaca en la Figura 18-8:
Figura 18-8
A continuación, seleccione la única vista Button en la segunda fila, esta vez cambiando el diseño
correspondiente: valor ColumnSpan en el panel Propiedades para 2.
Estos dos puntos de vista están configurados para abarcar varias células. Una revisión de la lona de la
disposición, sin embargo, muestra que las opiniones se han mantenido el mismo tamaño, aunque las células en
las que residen ahora abarcan varias filas o columnas. La razón de esto es que la configuración de gravedad
para estas vistas necesitan ser cambiados.
Cambio de la gravedad de un GridLayout Niño

Las propiedades de la gravedad de los puntos de vista de un niño GridLayout dictan el tamaño y la posición de
los puntos de vista relativos a la celda en la que esas opiniones están contenidas. Por defecto, las vistas añaden
hasta ahora en este capítulo se han creado para estar alineado con la esquina superior izquierda de las celdas
que contienen. Con el fin de hacer que el celular anterior abarca visible, la gravedad de los dos puntos de vista
Botón necesita ser cambiado para que los puntos de vista ocupan el espacio disponible.
Una opción es para centrar la vista del niño dentro de la célula. Comience por seleccionar la vista del botón
superior derecha. En el panel Propiedades, busque el diseño: línea de gravedad y haga clic en el campo de
valor central para desplegar una lista de opciones disponibles. En la lista, seleccione el valor vertical como se
muestra en la Figura 18-9:
Figura 18-9
Un subconjunto de propiedades de gravedad también se puede configurar con el botón de la barra de

herramientas Gravedad Diseñador como se ilustra en la Figura 18-10:
Figura 18-10
Habiendo establecido esta propiedad, la vista Button ahora estará centrado verticalmente entre las dos células:
Figura 18-11
Una opción alternativa a la de centrado es para la vista del niño para llenar el espacio disponible. Para lograr
esto, cambie el ajuste de relleno del trazado: la propiedad gravedad para fill_vertical. Es importante señalar que
las diferentes categorías de propiedades de gravedad se combinan como se seleccionan. Para la celda
seleccionada, por ejemplo, ahora hemos permitido ambas propiedades gravedad center_vertical y
fill_vertical. Esto se puede verificar haciendo referencia a la disposición: línea de gravedad en el panel
Propiedades como se indica en la Figura 18-12:
Figura 18-12
Desde la propiedad center_vertical ya no es necesario, apáguelo bajar por el menú propiedad del centro (Figura
18-13) y seleccionando el <unset> opción:
Figura 18-13
Añadir una propiedad gravedad para el botón de la segunda fila, esta vez permitiendo el ajuste de la gravedad
fill_horizontal. Después de cambiar las banderas de gravedad, los dos botones deberían haber ampliado para
rellenar las celdas abarcado:
Figura 18-14
Resumen
La clase GridLayout permite vistas a ser dispuestos en un diseño de cuadrícula, donde una o más vistas están
contenidas dentro de las cuadrículas. Cada niño puede ser configurado para abarcar varias células tanto
horizontal como verticalmente. El comportamiento de la posición y el tamaño de una vista de niño dentro de una
celda o rango de celdas se controla a través de la configuración de los valores de gravedad.
GridLayouts podrán ser ejecutadas bien mediante el Diseñador de Android Estudio en modo de diseño, o
mediante el uso de código Java o recursos de diseño XML. En este capítulo se ha cubierto el enfoque de modo
de diseño. El siguiente capítulo se analizará el uso de los recursos de diseño XML para implementar
configuraciones GridLayout.
18 Trabajar con el GridLayout Android usando Recursos
Disposición XML
En el capítulo anterior (titulado Uso del Administrador de Android GridLayout en Android Studio Designer)
introdujo los conceptos básicos de la gerente Android GridLayout antes de explicar cómo crear un diseño de
interfaz de usuario basada GridLayout utilizando el modo de diseño de la herramienta Android Studio
Designer. Visualmente el diseño de una interfaz de usuario basada en GridLayout no es, sin embargo, el único
método disponible de trabajar con la clase GridLayout. Estos diseños también pueden implementarse
escribiendo directamente el código de Java o de forma manual la creación de elementos en un archivo de
formato XML, el último de los cuales es el tema de este capítulo.
GridLayouts en archivos de recursos XML

Un GridLayout se declara dentro de un archivo XML utilizando el <GridLayout> etiqueta de elemento. Por
ejemplo:
<GridLayout xmlns: android = "http://schemas.android.com/apk/res/android"

android: id = "@ + / Identificación del GridLayout1"
android: orientación = "vertical"
herramientas: context = ". GridLayoutActivity">
</ GridLayout>
La sintaxis XML anterior se aplica cuando el GridLayout es el elemento raíz de un diseño de interfaz de usuario
(es decir, el diseño superior más importantes en la jerarquía de la vista). En situaciones en las que el GridLayout
está anidado como un hijo de otro recipiente los cambios de sintaxis ligeramente. El siguiente XML, por ejemplo,
muestra un ejemplo GridLayout incrustado en un gestor de RelativeLayout donde el RelativeLayout es el
elemento raíz de la interfaz de usuario:

<GridLayout
android: layout_alignParentTop = "true"
android: layout_alignParentLeft = "true"
android: layout_alignParentStart = "true"
android: orientación = "vertical">
</ GridLayout>
</ RelativeLayout>
El número de filas y columnas dentro de la red puede ser declarada usando el androide: rowCount y android:
columnCount propiedades. Típicamente, sin embargo, si se declara el número de columnas de la GridLayout
inferirá el número de filas basado en el número de celdas ocupadas haciendo el uso de la propiedad rowCount
innecesario.
Del mismo modo, la orientación de la GridLayout opcionalmente se puede definir a través de la androide: la
propiedad de orientación. El siguiente ejemplo XML declara una configuración de 2 x 2 GridLayout en
orientación horizontal:

android: columnCount = "2"
android: rowCount = "2"
android: orientación = "horizontal"
</ GridLayout>
Adición de Niños Vistas a la GridLayout

Puntos de vista del niño se pueden agregar a un GridLayout declarando los elementos dentro de la
<GridLayout> estructura en el archivo XML. Si son declarados no hay valores de fila y columna para un niño que
se coloca automáticamente por la clase GridLayout basado en la configuración de la representación y la
posición de la vista en el archivo XML. El siguiente código XML coloca cuatro botones en el GridLayout anterior,
a cada pantalla colocada en la esquina superior izquierda de la celda de encapsulamiento:

android: columnCount = "2"
android: rowCount = "2"
<Botón
android: id = "@ + / Identificación del botón 1"
android: layout_gravity = "left | top"
android: text = "Button" />
<Botón
android: id = "@ + / Identificación del button2"
<Botón
<Botón
</ GridLayout>
La disposición anterior se representa visualmente como se ilustra en la Figura 19-1:
Figura 19-1
Una vista puede ser colocado dentro de una celda específica, indicando la fila y la columna número de
intersección de la celda de destino. La siguiente vista Button, por ejemplo, se colocará en la celda ubicada en la
fila 1, columna 2 de la GridLayout padre:
<Botón
android: layout_column = "2"
android: layout_row = "1"
Declarando Spanning Cell, Gravedad y Márgenes

El hijo de un GridLayout se puede configurar para abarcar varias células usando el androide: layout_rowSpan y
Android: propiedades layout_columnSpan. La gravedad del niño se controla a través del androide: propiedad
layout_gravity.
En el fragmento de XML a continuación, una vista del botón está configurado para abarcar 3 columnas y filas 2 y
para llenar el espacio disponible tanto horizontal como verticalmente:
<Botón
android: layout_columnSpan = "3"
android: layout_rowSpan = "2"
android: layout_gravity = "llenar"
Los márgenes alrededor de una vista dentro de una célula pueden ser declaradas para todos los lados de la
vista con el androide: propiedad margin layout_margin. Alternativamente, los márgenes de los distintos lados
pueden definirse utilizando el topmargin, BottomMargin, leftmargin y rightmargin propiedades. La siguiente vista
Botón declara un margen 10DP por los cuatro costados:
<Botón
android: layout_margin = "10DP"
Llevar este conocimiento en conjunto, que ahora puede revisar el diseño de XML para la interfaz de usuario
basada en GridLayout creado en el capítulo anterior:
<GridLayout
<Botón
android: text = "Nuevo Botón"
android: layout_columnSpan = "2"
android: layout_gravity = "fill_horizontal" />
<Botón
android: layout_column = "1" />
<Botón
android: layout_column = "0" />
<Botón
android: layout_rowSpan = "2"
android: layout_gravity = "fill_vertical" />
</ GridLayout>
El fragmento de archivo de recursos arriba aparece exactamente como se creó dentro de la herramienta
Diseñador Android Estudio en el capítulo anterior.Como se puede ver, que contiene un administrador de
GridLayout y cuatro vistas del botón con posiciones celulares especificadas por las propiedades de fila y
columna. Finalmente, los valores de referencia de fila y columna, junto con propiedades de gravedad se utilizan
para hacer dos de los botones de abarcar múltiples células. Cuando se implementa dentro de una aplicación,
este diseño XML aparecería como se ilustra en la figura 16-13.
Resumen
Como alternativa al uso de la herramienta Android Studio Designer en modo de diseño para crear elementos de
la interfaz de usuario basada GridLayout, el mismo objetivo también se puede lograr mediante la creación
manual de recursos de diseño XML. Después de haber cubierto el uso del enfoque de diseño gráfico en el
capítulo anterior, este capítulo ha cubierto los conceptos de declarar un GridLayout y posicionamiento y
configuración de puntos de vista del niño dentro de un archivo de recursos XML.
19 Una visión general y Android Estudio Ejemplo de Manejo
Android Evento (An Overview and Android Studio Example of Android Event Handling)
Mucho se ha cubierto en los capítulos anteriores relacionados con el diseño de interfaces de usuario para
aplicaciones de Android. Un área que todavía tiene que ser cubiertos, sin embargo, implica la manera en que la
interacción de un usuario con la interfaz de usuario desencadena la actividad subyacente para realizar una
tarea. En otras palabras, sabemos de los capítulos anteriores cómo crear una interfaz de usuario que contiene
una vista de botón, pero no la forma de hacer que algo suceda dentro de la aplicación, cuando es tocado por el
usuario.
El objetivo principal de este capítulo, por lo tanto, es proporcionar una visión general de la gestión de eventos en
las aplicaciones de Android, junto con un ejemplo de proyecto basado en Android Studio. Una vez que los
fundamentos de la gestión de eventos han sido cubiertos, el capítulo siguiente cubrirá el manejo en cuanto a la
detección de múltiples toques y toque de movimiento toque evento.
Eventos Android
Eventos en Android pueden tomar una variedad de formas diferentes, pero por lo general se generan en
respuesta a una acción exterior. La forma más común de los acontecimientos, en particular para los dispositivos
tales como tabletas y smartphones, implica algún tipo de interacción con la pantalla táctil. Estos eventos entran
en la categoría de eventos de entrada.
El marco Android mantiene una cola de eventos en el que los eventos se colocan a medida que ocurren. Los
eventos se eliminan de la cola en un primero en entrar, primero en salir (FIFO),. En el caso de un evento de
entrada tales como un toque en la pantalla, el evento es pasado a la vista ubicado en la posición en la pantalla
donde el contacto se llevó a cabo. Además de la notificación de eventos, la vista también se aprobó una gama
de información (dependiendo del tipo de evento) acerca de la naturaleza del evento, como las coordenadas del
punto de contacto entre la punta del dedo del usuario y la pantalla.
Con el fin de ser capaz de manejar el caso de que no haya sido aprobada, la vista debe contar con un detector
de eventos. La clase View Android, del que se derivan todos los componentes de la interfaz de usuario, contiene
una gama de interfaces de detectores de evento, cada uno de los cuales contiene una declaración abstracta de
un método de devolución de llamada. Con el fin de ser capaces de responder a un evento de un tipo particular,
una vista debe registrar el detector evento apropiado y aplicar la devolución de llamada correspondiente. Por
ejemplo, si un botón es para responder a un evento click (el equivalente a la conmovedora usuario y soltando el
botón de vista como si al hacer clic en un botón físico) se debe tanto a registrar el detector de eventos
View.OnClickListener (a través de una llamada a la meta el método de vista setOnClickListener ()) y poner en
práctica el método de devolución de llamada correspondiente onClick (). En el caso de que un evento de "click"
se detecta en la pantalla a la ubicación de la vista botón, el marco Android llamará al método onClick () de ese
punto de vista, cuando ese evento se elimina de la cola de eventos. Es, por supuesto, dentro de la
implementación del método de devolución de llamada onClick () que las tareas deben realizarse u otros métodos
llamado en respuesta a el botón de clic.
Uso de Android: Recursos onClick

Antes de explorar los detectores de eventos con más detalle vale la pena señalar que un acceso directo está
disponible cuando lo único que se requiere es un método de devolución de llamada que se llamará cuando un
usuario haga "clic" en una vista botón en la interfaz de usuario. Considere la posibilidad de un diseño de interfaz
de usuario que contiene una vista botón denominado Button1 con el requisito de que cuando el usuario toca el
botón, un método llamado buttonClick () declarada en la clase de actividad que se llama. Todo lo que se
requiere para implementar este comportamiento es escribir el método buttonClick () (que toma como argumento
una referencia a la opinión de que ha activado el evento click) y añadir una sola línea para la declaración de la
opinión de botón en el archivo XML. Por ejemplo:
<Botón
android: onClick = "buttonClick"
android: text = "Haga clic en mí" />
Esto proporciona una manera sencilla de capturar eventos de clic. No, sin embargo, proporciona la gama de
opciones ofrecidas por los controladores de eventos, que son el tema del resto de este capítulo. Cuando se
trabaja en Android Studio Designer, la propiedad onClick se puede encontrar y configurado en el panel
Propiedades cuando se selecciona un tipo de vista adecuado en el diseño de la pantalla del dispositivo.
Detectores de eventos y métodos de devolución de llamada

En la actividad de ejemplo se indica más adelante en este capítulo los pasos necesarios para registrar un
detector de eventos y aplicar el método de devolución de llamada se tratarán en detalle. Antes de hacerlo, sin
embargo, vale la pena tomar algún tiempo para delinear los detectores de eventos que están disponibles en el
marco de Android y los métodos de devolución de llamada asociados a cada uno.
 OnClickListener - Se utiliza para detectar eventos de clic de estilo por el que los toques de usuario y
luego libera un área de la pantalla del dispositivo ocupada por una vista. Se corresponde con el método de
devolución de llamada onClick () que se pasa una referencia a la opinión de que ha recibido el evento como
un argumento.
 onLongClickListener - Se utiliza para detectar cuando el usuario mantiene el contacto a través de
una vista por un período prolongado. Se corresponde con el método de devolución de llamada onLongClick
() que se pasa como argumento la opinión de que recibió el evento.
 onTouchListener - Se usa para detectar cualquier tipo de contacto con la pantalla táctil que incluye
toques individuales o múltiples y movimientos gestuales. En correspondencia con la devolución de llamada
onTouch (), este tema se tratará con mayor detalle en el capítulo titulado Android táctil y Multi-touch Manejo
de Eventos. El método de devolución de llamada se pasa como argumentos la opinión de que ha recibido el
evento y un objeto MotionEvent.
 onCreateContextMenuListener - Escucha la creación de un menú contextual como el resultado de
una larga clic. Se corresponde con el método de devolución de llamada onCreateContextMenu (). La
devolución de llamada se pasa al menú, la opinión de que recibió el evento y un objeto de contexto menú.
 onFocusChangeListener - Detecta cuando el enfoque se aleja de la vista actual como el resultado de
la interacción con un trackball o la tecla de navegación. Se corresponde con el método de devolución de
llamada onFocusChange () que se transmite la idea de que ha recibido el evento y un valor booleano para
indicar si el foco se gana o se pierde.
 onKeyListener - Se utiliza para detectar cuando se pulsa una tecla en un dispositivo, mientras que un
punto de vista tiene el foco. Se corresponde con el método de devolución de llamada OnKey (). Pasa como
argumentos son la opinión de que recibió el evento, el código de tecla de la tecla física que se presionó y
un objeto KeyEvent.
Un ejemplo Manejo de Eventos
En el resto de este capítulo, vamos a trabajar a través de la creación de un proyecto simple Android Estudio
diseñado para demostrar la implementación de un detector de eventos y el método de devolución de llamada
correspondiente para detectar cuando el usuario ha hecho clic en un botón. El código dentro del método de
devolución de llamada se actualizará una vista de texto para indicar que el evento ha sido procesado.
Crear un nuevo proyecto en Android de estudio, entrar EventExample en el campo Nombre de la aplicación y
ebookfrenzy.com como el ajuste de dominio de la empresa antes de hacer clic en el botón Siguiente.
actividad en blanco denominada EventExampleActivity con una disposición correspondiente llamado
activity_event_example.

El diseño de la interfaz de usuario para la clase EventExampleActivity en este ejemplo es para consistir en una
vista RelativeLayout, un botón y un TextView como se ilustra en la Figura 20-1.
Figura 20-1
Busque y seleccione el archivo activity_event_example.xml creado por Android Studio (situado en la ventana de
herramientas Proyecto en EventExample -> aplicación -> src -> principal -> res -> layouts) y haga doble clic en
él para cargarlo en la herramienta Diseñador. Pasar del modo Diseño en modo texto usando la pestaña en la
parte inferior del panel Diseñador y borrar el contenido actual del archivo. Con un lienzo en blanco, ya sea para
uso el modo de diseño para diseñar visualmente la interfaz de usuario de la figura 20-1 (asegurándose de
cambiar los ID de la Button y TextView objeta @ + / Identificación del myButton y @ + / Identificación del
myTextView respectivamente), o directamente introducir el siguiente código XML se utiliza el modo texto:

android: id = "@ + / Identificación del myLayout"
android: layout_width = "fill_parent"
android: layout_height = "fill_parent">
<Botón
android: id = "@ + / Identificación del myButton"
android: text = "Pulse Me" />
<TextView
android: id = "@ + / Identificación del myTextView"
android: layout_above = "@ + / Identificación del myButton"
android: text = "Estado"
android: textAppearance = "android:? attr / textAppearanceLarge" />
</ RelativeLayout>
Cambiar al modo de diseño, y seleccione la etiqueta de estado en el diseño de la pantalla del

dispositivo. Cuando aparezca el icono de la bombilla, haga clic sobre él y seleccione el mensaje de advertencia
cadena I18N codificado para mostrar el diálogo Extract Resource. En el cuadro de diálogo, el nombre de la
cadena status_string recurso y haga clic en el botón Aceptar. Repita estos pasos para la visualización por
botones, esta vez nombrando el button_string recurso de cadena.
Con el diseño de la interfaz de usuario ya ha concluido, el siguiente paso es registrar el detector de eventos y el
método de devolución de llamada.
El detector de eventos y método de devolución de llamada

A los efectos de este ejemplo, un OnClickListener necesita ser registrada para la vista myButton. Esto se logra
mediante una llamada al método setOnClickListener () de la vista de botón, que pasa a través de un nuevo
objeto OnClickListener como argumento y la aplicación del método de devolución de llamada onClick (). Dado
que esta es una tarea que sólo necesita ser realizada cuando se crea la actividad, una buena ubicación es el
método onCreate () de la clase EventExampleActivity.
Si el archivo EventExampleActivity.java ya está abierto en una sesión editor, selecciónelo haciendo clic en la
pestaña en el panel del editor. Alternativamente ubicarlo dentro de la ventana de herramientas Proyecto
navegando a (EventExample -> aplicación -> src -> principal -> Java -> com.ebookfrenzy.eventexample ->
EventExampleActivity) y haga doble clic en él para cargarlo en el editor de código. Una vez cargado, localizar el
método onCreate () plantilla y modificarla para obtener una referencia a la opinión de botón, registrar el detector
de eventos y aplicar el método de devolución de llamada onClick ():
com.ebookfrenzy.eventexample paquete;
android.view.View importación;
android.widget.TextView importación;
public class EventExampleActivity extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_event_example);
Botón Botón = (Button) findViewById (R.id.myButton);
button.setOnClickListener (
nueva Button.OnClickListener () {
public void onClick (View v) {
}
}
);
}
.
.
.
}
El código anterior se ha registrado el detector de eventos en el botón y aplicado el método onClick (). Si la
aplicación fuera a ser ejecutado en este punto, sin embargo, no habría ninguna indicación de que el detector de
eventos instalado en el botón estaba trabajando ya que no es, hasta ahora, ningún código implementado dentro
del cuerpo del método de devolución de llamada onClick (). La meta para el ejemplo es tener un mensaje
aparecerá en la TextView cuando se hace clic en el botón, por lo que algunos cambios de código adicionales
deben hacerse:
@ Override
TextView myTextView =
(TextView) findViewById (R.id.myTextView);
myTextView.setText ("Botón de clic");
}
}
);
}
Completar esta fase del tutorial de compilar y ejecutar la aplicación en ambos un emulador AVD o dispositivo
Android física. Al tocar y soltar el botón de vista (también conocido como "clic") la vista de texto debería cambiar
para mostrar el texto "Botón de clic".
Utilizar eventos
La detección de clics estándar (a diferencia de clics largos) en puntos de vista es un caso muy simple de manejo
de eventos. El ejemplo se extenderá ahora para incluir la detección de eventos de clic largos que se producen
cuando el usuario hace clic y sostiene una vista en la pantalla y, al hacerlo, cubren el tema del consumo de
evento.
Considere el código para el método onClick () en la sección anterior de este capítulo. La devolución de llamada
se declara nulo y, como tal, no devuelve un valor para el sistema Android después de que haya terminado de
ejecutarse. El onLongClick () método de devolución de llamada de la interfaz onLongClickListener, por el
contrario, tiene la obligación de devolver un valor booleano al marco Android. El propósito de este valor de
retorno es para indicar que el tiempo de ejecución Android si o no la devolución de llamada ha consumido el
evento. Si la devolución de llamada devuelve un valor verdadero, el evento se descarta por el marco. Si, por el
contrario, la devolución de llamada devuelve un valor falso el marco Android considerará el evento aún estar
activo y en consecuencia lo pasará junto al detector de eventos siguiente juego que está registrado en el mismo
punto de vista.
Al igual que con muchos conceptos de programación esto es, tal vez, mejor demostrado con un ejemplo. El
primer paso es añadir un detector de eventos y el método de devolución de llamada durante largos clics a la
vista botón en la actividad de ejemplo:
@ Override
myTextView.setText ("Botón de clic");
}
}
);
button.setOnLongClickListener (
nueva Button.OnLongClickListener () {
public boolean onLongClick (Ver v) {
myTextView.setText ("botón Larga clic");
return true;
}
}
);
}
Es evidente que, cuando se detecta una pulsación larga, el método de devolución de llamada onLongClick ()
mostrará "clic de botón largo" en la vista de texto.Nótese, sin embargo, que el método de devolución de llamada
también devuelve un valor de true para indicar que se ha consumido el evento. Compilar y ejecutar la aplicación
y pulse y mantenga la punta del dedo sobre la vista botón hasta que el "botón de Long clic en" texto aparece en
la vista de texto. Al soltar el botón, la vista de texto sigue mostrando el texto "botón Larga clic" que indica que el
método de devolución de llamada onClick () no fue llamado.
A continuación, modifique el código de tal manera que el método onLongClick () ahora devuelve un valor falso:
button.setOnLongClickListener (
nueva Button.OnLongClickListener () {
public boolean onLongClick (Ver v) {
TextView myTextView = (TextView) findViewById
(R.id.myTextView);
myTextView.setText ("botón Larga clic");
return false;
}
}
);
Una vez más, compilar y ejecutar la aplicación y realizar una pulsación larga en el botón hasta que aparezca el
mensaje largo clic. Al soltar el botón de este tiempo, sin embargo, tenga en cuenta que la devolución de llamada
onClick () también se activa y el texto cambia a "Botón de clic". Esto es porque el valor falso devuelto por el
método de devolución de llamada onLongClick () indica al marco Android que el evento no fue consumido por el
método y era elegible para ser pasado a la siguiente listener registrado en la vista. En este caso, el tiempo de
ejecución de determinarse que la OnClickListener en el botón también estaba interesado en los eventos de este
tipo y, posteriormente llamado el método de devolución de llamada onClick ().
Resumen
Una interfaz de usuario es de poca utilidad práctica si las opiniones que contiene no hacer nada en respuesta a
la interacción del usuario. Android cierra la brecha entre la interfaz de usuario y el código de extremo posterior
de la aplicación a través de los conceptos de los detectores de eventos y los métodos de devolución de
llamada. La clase Android Ver define un conjunto de detectores de eventos, que pueden estar registradas en
objetos de vista. Cada detector de eventos también se ha asociado con un método de devolución de llamada.
Cuando un evento tiene lugar en un punto de vista en una interfaz de usuario, ese evento se coloca en una cola
de eventos y manejado en un primero en entrar, primero en salir por la base de tiempo de ejecución Android. Si
la vista en la que tuvo lugar el evento ha registrado un oyente que coincida con el tipo de evento, se llama al
método de devolución de llamada correspondiente. El método de devolución de llamada y luego realiza las
tareas requeridas por la actividad antes de regresar. Se requieren algunos métodos de devolución de llamada
para devolver un valor booleano para indicar si el evento tiene que ser transmitida a otros detectores de eventos
registrados en la vista o descartados por el sistema.
Después de haber cubierto los conceptos básicos de la gestión de eventos, el siguiente capítulo explorará con
cierta profundidad el tema de los eventos de toque con un énfasis particular en el manejo de múltiples toques.
20 Touch Android y multi-touch control de eventos en
Android Estudio
La mayoría de los dispositivos basados en Android utilizan una pantalla táctil como interfaz principal entre el
usuario y el dispositivo. En el capítulo anterior introdujo el mecanismo por el cual un toque en la pantalla se
traduce en una acción dentro de una aplicación de Android corriendo. Hay, sin embargo, mucho más que toque
la gestión de eventos de responder a un solo toque del dedo sobre un objeto de vista. La mayoría de los
dispositivos Android pueden, por ejemplo, detectar más de un contacto a la vez. Tampoco son toques limitados
a un solo punto en la pantalla del dispositivo. Toques pueden, por supuesto, ser dinámico como el usuario
desliza uno o más puntos de contacto a través de la superficie de la pantalla.
Toques también pueden ser interpretados por una aplicación como un gesto. Consideremos, por ejemplo, que
un golpe horizontal se suele utilizar para pasar la página de un libro electrónico, o cómo un movimiento de
pellizco se puede utilizar para acercar y alejar una imagen que aparece en la pantalla.
El objetivo de este capítulo es para resaltar el manejo de los detalles que implican movimiento y para explorar el
concepto de interceptar múltiples toques simultáneos. El tema de la identificación de los gestos distintos se
cubrirá en el próximo capítulo.
erceptar Eventos Touch

Toque eventos pueden ser interceptados por un objeto vista a través del registro de un detector de eventos
onTouchListener y la aplicación del método de devolución de llamada onTouch correspondiente (). El siguiente
código, por ejemplo, asegura que cualquier toques en una instancia de vista RelativeLayout llamado myLayout
resultado de una llamada al método onTouch ():
myLayout.setOnTouchListener (
nueva RelativeLayout.OnTouchListener () {
onTouch public boolean (Ver v, MotionEvent m) {
// Realizar tareas aquí
return true;
}
}
);
Como se indica en el ejemplo de código, se requiere la devolución de llamada onTouch () para devolver un valor
booleano que indica que el sistema de ejecución Android si el evento debe ser transmitida a otros detectores de
eventos registrados en el mismo punto de vista o descartados. El método se pasa tanto una referencia a la vista
en la que se activa el evento y un objeto de tipo MotionEvent.
El Objeto MotionEvent
El objeto MotionEvent pasado por el método de devolución de llamada onTouch () es la clave para la obtención
de información sobre el evento. La información contenida en el objeto incluye la ubicación del contacto dentro de
la vista y el tipo de acción realizada. El objeto MotionEvent es también la clave para el manejo de múltiples
toques.
A.Táctiles Comprensión
Un aspecto importante de la gestión de eventos táctil implica ser capaz de identificar el tipo de acción realizada
por el usuario. El tipo de acción asociado a un evento se puede obtener mediante una llamada al método del
objeto MotionEvent que fue aprobada mediante el método de devolución de llamada onTouch ()
getActionMasked (). Cuando se produce el primer contacto en una vista, el objeto MotionEvent contendrá un tipo
de acción de ACTION_DOWN junto con las coordenadas de tacto. Cuando ese contacto se levanta de la
pantalla, se genera un evento ACTION_UP. Cualquier movimiento del contacto entre los eventos
ACTION_DOWN y ACTION_UP estará representada por eventos ACTION_MOVE.
Cuando más de un toque se realiza simultáneamente en una vista, los toques se conocen como punteros. En un
escenario multi-touch, punteros comienzan y terminan con acciones de eventos de tipo ACTION_POINTER_UP
y ACTION_POINTER_DOWN respectivamente. Con el fin de identificar el índice del puntero que activa el
evento, el método de devolución de llamada getActionIndex () del objeto MotionEvent debe ser llamado.
Manejo de múltiples toques

En el capítulo anterior comenzó a explorar la manipulación en el estrecho marco de un evento único toque
evento. En la práctica, la mayoría de los dispositivos Android poseen la capacidad de responder a múltiples
toques consecutivos (aunque es importante señalar que el número de toques simultáneos que pueden ser
detectadas varía dependiendo del dispositivo).
Como se mencionó anteriormente, cada toque en una situación multi-touch es considerado por el marco Android
sea un puntero. Cada puntero, a su vez, hace referencia a un valor de índice y se asigna un ID. El número
actual de punteros se puede obtener a través de una llamada al método getPointerCount () del objeto
MotionEvent actual. El ID de un puntero a un determinado índice en la lista de punteros actuales se puede
obtener a través de una llamada al método MotionEvent getPointerId (). Por ejemplo, el siguiente fragmento de
código obtiene un recuento de punteros y el ID del puntero en el índice 0:
onTouch public boolean (Ver v, MotionEvent m) {

int pointerCount = m.getPointerCount ();
int pointerId = m.getPointerId (0);
return true;
}
Tenga en cuenta que el recuento de puntero siempre será mayor que o igual a 1 cuando se llama a un método
onTouch () (por lo menos desde un solo toque debe haber ocurrido durante la devolución de llamada para ser
activado).
Un toque en una vista, en particular uno que implica el movimiento a través de la pantalla, se generará un flujo
de eventos antes del punto de contacto con los que se levante la pantalla. Como tal, es probable que una
aplicación tendrá que realizar un seguimiento de toques individuales sobre múltiples eventos táctiles.Mientras
que el ID de un gesto táctil específica no cambiará de un evento a otro, es importante tener en cuenta que el
valor del índice cambiará a medida que otros eventos táctiles van y vienen. Cuando se trabaja con un gesto
contacto a través de múltiples eventos, por lo tanto, es esencial que el valor ID ser utilizado como la referencia
de contacto con el fin de asegurarse de que el mismo toque está siendo rastreado. Al llamar a métodos que
requieren un valor de índice, este debe ser obtenido mediante la conversión de la ID de un toque para el valor
del índice correspondiente a través de una llamada al método findPointerIndex () del objeto MotionEvent.
Un Multi-Touch Ejemplo de Aplicación

La aplicación de ejemplo creada en el resto de este capítulo se hará un seguimiento de hasta dos gestos táctiles
como se mueven a través de una vista de diseño. Como se desencadenan los eventos para cada contacto, las
coordenadas, el índice y el ID para cada contacto se mostrarán en la pantalla.
Crear un nuevo proyecto en Android de estudio, entrar MotionEvent en el campo Nombre de la aplicación y
actividad en blanco denominada MotionEventActivity con una disposición correspondiente llamado
activity_motion_event.
El diseño de la interfaz de la actividad del usuario

La interfaz de usuario única actividad de la aplicación debe consistir en una vista RelativeLayout que contiene
dos objetos TextView. Dentro de la ventana de herramientas del proyecto, vaya a MotionEvent -> aplicación ->
src -> principal -> res -> trazado y haga doble clic en el archivo de recursos de diseño activity_motion_event.xml
para cargarlo en la herramienta Android Studio Designer. Una opción es diseñar la disposición ilustrada en la
Figura 21-1 utilizando un RelativeLayout como la vista de la raíz y teniendo en cuenta que el componente
inferior TextView se centra horizontalmente dentro de la vista de los padres y el TextView superior se coloca a
una distancia relativa por encima de la TextView inferior. Cuando el esquema de trazado se haya completado,
haga doble clic en el RelativeLayout (esencialmente el fondo de la disposición) y establecer el ID de @ + /
Identificación del RelativeLayout1. Repita estos pasos para asignar identificadores @ + / Identificación del
textView1 y @ + / Identificación del textView2 a los componentes TextView.
Como alternativa, cambie al editor XML seleccionando la ficha Texto en la parte inferior del panel Diseñador y
reemplace el código XML actual por el siguiente:
android: id = "@ + / Identificación del RelativeLayout1"
android: layout_height = "fill_parent">
<TextView
android: id = "@ + / Identificación del textView2"
android: text = "Toque Dos Status" />
<TextView
android: layout_above = "@ + / Identificación del textView2"
android: layout_alignLeft = "@ + / Identificación del textView2"
android: text = "Touch Uno de estado" />
</ RelativeLayout>
Cambiar al modo de diseño y seleccione el TextView superior en el diseño de la pantalla del dispositivo. Cuando
aparezca el icono de la bombilla, haga clic sobre él y seleccione el mensaje de advertencia cadena I18N
codificado para mostrar el diálogo Extract Resource. En el cuadro de diálogo, el nombre de la cadena
status1_string recurso y haga clic en el botón Aceptar. Repita estos pasos para el segundo componente
TextView, esta vez nombrando el status2_string recurso de cadena.
Figura 21-1
Implementación del Evento Listener Touch

Para recibir notificaciones de eventos táctiles será necesario registrar un oyente toque en la vista
RelativeLayout1 dentro del método onCreate () de la clase de actividad MotionEventActivity. Selecciona la
pestaña MotionEventActivity.java desde el panel editor de Android Studio para mostrar el código fuente. Dentro
del método onCreate (), agregue código para identificar el objeto vista RelativeLayout, registrar el detector táctil
y aplicar el onTouch () método de devolución de llamada que, en este caso, se va a llamar a un segundo método
denominado handleTouch () a la que se pasa el MotionEvent objeto:
com.ebookfrenzy.motionevent paquete;
android.view.MotionEvent importación;
public class MotionEventActivity extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_motion_event);
RelativeLayout myLayout =
(RelativeLayout) findViewById (R.id.RelativeLayout1);
public boolean onTouch (Ver v,
MotionEvent m) {
handleTouch (m);
return true;
}
}
);
}
.
.
.
}
La última tarea antes de probar la aplicación es poner en práctica el método handleTouch () convocada por el
método de devolución de llamada onTouch (). El código de este método es el siguiente:
anular handleTouch (MotionEvent m)

{
TextView textView1 = (TextView) findViewById (R.id.textView1);
for (int i = 0; i <pointerCount; i ++)

{
int x = (int) m.getX (i);
int y = (int) m.getY (i);
int id = m.getPointerId (i);
int action = m.getActionMasked ();
int actionindex = m.getActionIndex ();
ActionString Cadena;
switch (acción)
{
caso MotionEvent.ACTION_DOWN:
actionString = "DOWN";
break;
caso MotionEvent.ACTION_UP:
actionString = "UP";
break;
caso MotionEvent.ACTION_POINTER_DOWN:
actionString = "RCNP DOWN";
break;
caso MotionEvent.ACTION_POINTER_UP:
actionString = "RCNP UP";
break;
caso MotionEvent.ACTION_MOVE:
actionString = "MOVE";
break;
por defecto:
actionString = "";
}
Cadena touchStatus = "Acción:" "Índice:" + + + actionString

actionindex + "ID:" + Identificación + "X:" + x + "Y:" + y;
si (id == 0)
textView1.setText (touchStatus);
más
}
}
Antes de compilar y ejecutar la aplicación, vale la pena tomarse el tiempo para caminar a través de este código
de forma sistemática para poner de relieve las tareas que se están realizando. El código empieza por la
obtención de referencias a los dos objetos TextView en la interfaz de usuario e identificar cuántos punteros
están activos actualmente en la vista:

A continuación, la variable pointerCount se utiliza para iniciar un bucle que realiza un conjunto de tareas para
cada puntero activo. Las primeras líneas del bucle obtienen la coordenadas X e Y del tacto junto con el
correspondiente identificador de evento, tipo de acción y el índice de la acción. Por último, una variable de
cadena se declara:
for (int i = 0; i <pointerCount; i ++)

{
int x = (int) m.getX (i);
int y = (int) m.getY (i);
int id = m.getPointerId (i);
int action = m.getActionMasked ();
int actionindex = m.getActionIndex ();
ActionString Cadena;
Puesto que los tipos de acción equivalen a valores enteros, una declaración interruptor se utiliza para convertir
el tipo de acción a un valor de cadena más significativo, que se almacena en la variable de actionString
declarada:
switch (acción)
{
caso MotionEvent.ACTION_DOWN:
actionString = "DOWN";
break;
caso MotionEvent.ACTION_UP:
actionString = "UP";
break;
caso MotionEvent.ACTION_POINTER_DOWN:
actionString = "RCNP DOWN";
break;
caso MotionEvent.ACTION_POINTER_UP:
actionString = "RCNP UP";
break;
caso MotionEvent.ACTION_MOVE:
actionString = "MOVE";
break;
por defecto:
actionString = "";
}
Por último, el mensaje de cadena se construye utilizando el valor actionString, el índice de acción, el tacto y el
ID coordenadas X e Y. El valor de ID se utiliza para decidir si la cadena se debe mostrar en el primer o segundo
objeto TextView:
Cadena touchStatus = "Acción:" + actionString + "Índice"

+ Actionindex + "ID:" + Identificación + "X:" + x + "Y:" + y;
si (id == 0)
más
Ejecutar la aplicación Ejemplo

Desde el entorno de emulador de Android no soporta multi-touch, compilar y ejecutar la aplicación en un
dispositivo Android física. Una vez lanzado, el experimento con toques simples y múltiples en la pantalla y tenga
en cuenta que la actualización de vistas de texto para reflejar los acontecimientos como se ilustra en la Figura
21-2:
Figura 21-2
Resumen
Actividades recibir notificaciones de eventos de toque al registrar un detector de eventos onTouchListener e
implementar el método de devolución de llamada onTouch () que, a su vez, se pasa un objeto MotionEvent
cuando se le llama por el tiempo de ejecución de Android. Este objeto contiene información sobre el tacto, tales
como el tipo de evento táctil, las coordenadas del tacto y un recuento del número de toques actualmente en
contacto con la vista. Cuando múltiples toques están involucrados, cada punto de contacto se conoce como un
puntero con cada uno asignado un índice y un ID. Mientras que el índice de un toque puede cambiar de un
evento a otro, el ID no cambiará hasta que termine el toque.
En este capítulo se ha trabajado a través de la creación de una aplicación para Android ejemplo diseñado para
mostrar las coordenadas y las acciones tipo de hasta dos toques simultáneos en una pantalla del dispositivo.
Tener toques cubiertos en general, el siguiente capítulo (titulado Detección Común Gestos con el Estudio de
Android y el Gesto Detector Class ) se verá más a fondo en la pantalla táctil de la gestión de eventos a través de
la aplicación de reconocimiento de gestos.
21 La detección de gestos comunes que utilizan Android

Studio y el Gesto Detector Clase
El término "gesto" se utiliza para definir una secuencia contigua de las interacciones entre la pantalla táctil y el
usuario. Un gesto típico comienza en el punto de que la pantalla es tocada primero y finaliza cuando el último
dedo o dispositivo de puntero sale de la superficie de la pantalla. Cuando se utiliza correctamente, los gestos
pueden implementarse como una forma de comunicación entre el usuario y la aplicación. El birlar mociones para
pasar las páginas de un libro electrónico, o un movimiento pellizcos que involucra a dos toques para acercar o
alejar una imagen son excelentes ejemplos de las formas en que los gestos se pueden utilizar para interactuar
con una aplicación.
El SDK de Android proporciona mecanismos para la detección de ambos gestos comunes y personalizados
dentro de una aplicación. Gestos comunes implican interacciones como un grifo, doble toque, pulsación larga o
una moción birlar ya sea en horizontal o una dirección vertical (mencionado en la nomenclatura Android como
una aventura).
El objetivo de este capítulo es explorar el uso de la clase GestureDetector Android para detectar gestos
comunes que se realizan en la pantalla de un dispositivo Android. El siguiente capítulo, titulado reconocimiento
de gestos de aplicación Android personalizada con Android Estudio , cubrirá la detección de más complejos, los
gestos personalizados tales como movimientos circulares y pellizcos.
Implementación de Detección Gesto Común

Cuando un usuario interactúa con la pantalla de un dispositivo Android, el método onTouchEvent () de la
aplicación activa es llamado por el sistema y pasar objetos MotionEvent que contienen datos sobre el contacto
del usuario con la pantalla. Estos datos pueden interpretarse de identificar si el movimiento en la pantalla
coincide con un gesto común, como un grifo o un golpe. Esto puede lograrse con muy poco esfuerzo de
programación haciendo uso de la clase Android GestureDetectorCompat. Esta clase está diseñada
específicamente para recibir información de eventos de movimiento de la aplicación y para activar las llamadas
a métodos basados en el tipo de gesto común, en su caso, que se detectó.
Los pasos básicos en la detección de gestos comunes son los siguientes:
1. Declaración de una clase que implementa la interfaz GestureDetector.OnGestureListener incluyendo la
onFling requerido (), onDown (), OnScroll (), onShowPress, onSingleTapUp () y onLongPress () los métodos
callback. Tenga en cuenta que esto puede ser o bien una clase completamente nueva, o la clase de actividad de
encerramiento. En el caso de que se requiere una detección doble toque gesto, la clase debe implementar la
interfaz GestureDetector.OnDoubleTapListener e incluir el método onDoubleTap correspondiente ().
2. Creación de una instancia de la clase Android GestureDetectorCompat, pasando a través de una instancia de
la clase creada en el paso 1 como argumento.
3. Una llamada opcional al método setOnDoubleTapListener () de la instancia GestureDetectorCompat para
permitir la detección doble toque si es necesario.
4. Aplicación del método de devolución de llamada onTouchEvent () sobre la actividad que encierra lo que, a su
vez, debe llamar al método onTouchEvent () de la instancia GestureDetectorCompat, pasando por el objeto de
evento de movimiento actual como argumento para el método.
Una vez implementado, el resultado es un conjunto de métodos dentro del código de la aplicación que se
llamarán cuando se detecta un gesto de un tipo particular. El código dentro de estos métodos puede ser
implementado para realizar las tareas que deben realizarse en respuesta al gesto correspondiente.
En el resto de este capítulo, vamos a trabajar a través de la creación de un proyecto de ejemplo que nos
permitirá mantener los pasos anteriores en práctica.
Creación de un proyecto de detección de gestos Ejemplo

El objetivo de este proyecto es detectar la gama de gestos comunes en la actualidad con el apoyo de la clase
GestureDetectorCompat y para mostrar la información de estado al usuario que indica el tipo de gesto que se ha
detectado.
Crear un nuevo proyecto en Android de estudio, entrar CommonGestures en el campo Nombre de la aplicación
y ebookfrenzy.com como el ajuste de dominio de la empresa antes de hacer clic en el botón Siguiente.
actividad en blanco denominada CommonGesturesActivity con una disposición correspondiente nombre
activity_common_gestures.
Una vez que el nuevo proyecto se ha creado, vaya a los CommonGestures -> aplicación -> src -> principal ->
res -> diseño -> archivo activity_common_gestures.xml en la ventana de herramientas del proyecto y haga doble
clic en él para cargarlo en la herramienta Diseñador .
Dentro de la herramienta de diseño, haga doble clic en el Hola, mundo! TextView componente y, en la ventana
emergente de propiedades, introduzca gestureStatusText como ID. Finalmente, mueva el TextView de modo
que se posiciona en el centro de la pantalla.
La implementación de la clase Listener

Como se ha señalado anteriormente, es necesario crear una clase que implementa la interfaz
GestureDetector.OnGestureListener y, si se requiere la detección de doble toque, la interfaz
GestureDetector.OnDoubleTapListener. Mientras que esto puede ser una clase completamente nueva, también
es perfectamente válida para implementar esta dentro de la clase de actividad actual. Para los fines de este
ejemplo, por lo tanto, vamos a modificar la clase CommonGesturesActivity para implementar estas interfaces
oyentes. Edite el archivo CommonGesturesActivity.java para que se lea de la siguiente manera para declarar las
interfaces y para extraer y almacenar una referencia al componente TextView en la interfaz de usuario:
com.ebookfrenzy.commongestures paquete;
android.view.GestureDetector importación;
public class CommonGesturesActivity extiende ActionBarActivity

implementa GestureDetector.OnGestureListener,
GestureDetector.OnDoubleTapListener {
privado gestureText TextView;
@ Override
setContentView (R.layout.activity_common_gestures);
gestureText =
(TextView) findViewById (R.id.gestureStatusText);
}
.
.
.
}
Declarando que la clase implementa los mandatos interfaces oyentes que los métodos correspondientes
también se implementarán en la clase:
com.ebookfrenzy.commongestures paquete;
@ Override
gestureText =
}
@ Override
onDown public boolean (evento MotionEvent) {
gestureText.setText ("onDown");
return true;
}
@ Override
onFling public boolean (MotionEvent event1, MotionEvent event2,
flotar velocityX, velocityY float) {
gestureText.setText ("onFling");
return true;
}
@ Override
public void onLongPress (evento MotionEvent) {
gestureText.setText ("onLongPress");
}
@ Override
OnScroll public boolean (MotionEvent e1, e2 MotionEvent,
flotar distanceX, flotar distanceY) {
gestureText.setText ("OnScroll");
return true;
}
@ Override
public void onShowPress (evento MotionEvent) {
gestureText.setText ("onShowPress");
}
@ Override
onSingleTapUp public boolean (evento MotionEvent) {
gestureText.setText ("onSingleTapUp");
return true;
}
@ Override
onDoubleTap public boolean (evento MotionEvent) {
gestureText.setText ("onDoubleTap");
return true;
}
@ Override
onDoubleTapEvent public boolean (evento MotionEvent) {
gestureText.setText ("onDoubleTapEvent");
return true;
}
@ Override
public boolean onSingleTapConfirmed (evento MotionEvent) {
gestureText.setText ("onSingleTapConfirmed");
return true;
}
.
.
.
}
Tenga en cuenta que todos estos métodos devuelven true. Esto indica al Marco de Android que el evento ha
sido consumido por el método y no necesita ser pasado al siguiente controlador de eventos en la pila.
Creación de la GestureDetectorCompat Instancia

Con la clase de actividad ahora actualizado para implementar las interfaces oyentes, el siguiente paso es crear
una instancia de la clase GestureDetectorCompat. Ya que esto sólo debe realizarse una vez en el punto que se
crea la actividad, el mejor lugar para este código está en el método onCreate (). Puesto que también queremos
detectar dobles grifos, el código también tiene que llamar al método setOnDoubleTapListener () de la instancia
GestureDetectorCompat:
com.ebookfrenzy.commongestures.commongestures paquete;
android.support.v4.view.GestureDetectorCompat importación;


privado gDetector GestureDetectorCompat;
@ Override
gestureText =
this.gDetector = new GestureDetectorCompat (esto, este);

gDetector.setOnDoubleTapListener (this);
}
.
.
}
La implementación de la onTouchEvent Método ()

Si la solicitud se deberán elaborar y ejecutar en este punto, no pasaría nada si los gestos se realizaron en la
pantalla del dispositivo. Esto es porque no hay código ha sido añadido a interceptar eventos táctiles y pase a
través de ellos a la instancia GestureDetectorCompat. Con el fin de lograr esto, es necesario reemplazar el
método onTouchEvent () dentro de la clase de actividad y aplicarlo tal que llama al método onTouchEvent () de
la instancia GestureDetectorCompat. Permanecer en el archivo CommonGesturesActivity.java, por lo tanto,
poner en práctica este método para que se lea de la siguiente manera:
@ Override
onTouchEvent public boolean (evento MotionEvent) {
this.gDetector.onTouchEvent (evento);
// Asegúrese de llamar a la implementación de la superclase
volver super.onTouchEvent (evento);
}
Compila y ejecuta la aplicación en un dispositivo Android, ya sea físico o un emulador AVD. Una vez puesto en
marcha, experimentar con golpes, prensas, movimientos de desplazamiento y grifos dobles e
individuales. Tenga en cuenta que la vista se actualiza texto para reflejar los acontecimientos tal como se ilustra
en la Figura 22-1:
Figura 22-1
Resumen
Cualquier contacto físico entre el usuario y la pantalla táctil de un dispositivo puede ser considerado como un
"gesto". Careciendo el teclado físico y el puntero del ratón de un sistema informático tradicional, los gestos se
utilizan ampliamente como un método de interacción entre el usuario y la aplicación. Mientras que un gesto
puede estar compuesto por casi cualquier secuencia de movimientos, hay un conjunto ampliamente utilizado de
gestos con los que los usuarios de los dispositivos de pantalla táctil se han familiarizado. Un número de estos
llamados "gestos comunes" se puede detectar fácilmente dentro de una aplicación, haciendo uso de las clases
Detector Gesto Android. En este capítulo, el uso de esta técnica se ha descrito tanto en la teoría como a través
de la implementación de un proyecto de ejemplo.
Tener gestos comunes tratados en este capítulo, el siguiente capítulo se verá en la detección de una gama más
amplia de tipos de gestos, incluyendo la capacidad de diseño y detectar sus propios gestos.
22 La implementación de reconocimiento de gestos Android

personalizada con Android Estudio
El capítulo anterior examinó los pasos involucrados en la detección de lo que se conoce como "gestos comunes"
desde una aplicación Android. En la práctica, sin embargo, un gesto puede tener componentes casi cualquier
secuencia de movimientos táctiles en la pantalla de un dispositivo Android. En reconocimiento de este hecho, el
SDK de Android permite gestos personalizados de casi cualquier naturaleza a ser definidas por el desarrollador
de la aplicación y se utilizan para activar eventos cuando es realizada por el usuario. Este es un proceso de
varias etapas, cuyos detalles son el tema de este capítulo.
Gestor de Android Application Builder
El SDK de Android permite a los desarrolladores diseñar gestos personalizados que luego se almacenan en un
archivo gesto liado con un paquete de aplicaciones Android.Estos archivos gesto personalizado se crean más
fácilmente utilizando la aplicación Generador de gestos que se incluye con el paquete de muestras suministrado
como parte del SDK de Android. La creación de un archivo de gestos implica el lanzamiento de la aplicación
Generador de Gesto, ya sea en un dispositivo físico o emulador, y "dibujar" los gestos que necesitarán para ser
detectado por la aplicación. Una vez que los gestos se han diseñado, el archivo que contiene los datos de
gestos se puede sacar la tarjeta SD del dispositivo o emulador y se agrega al proyecto de aplicación. Dentro del
código de la aplicación, el archivo se carga en una instancia de la clase GestureLibrary donde se puede utilizar
para buscar coincidencias con los gestos realizados por el usuario en la pantalla del dispositivo.
La Clase GestureOverlayView
Con el fin de facilitar la detección de gestos dentro de una aplicación, el SDK de Android proporciona la clase
GestureOverlayView. Esta es una vista transparente que se puede colocar sobre otras vistas en la interfaz de
usuario para el único propósito de gestos de detección.
La detección de gestos
Los gestos son detectados por la carga del archivo gestos creado utilizando la aplicación Generador de Gesto y
luego registrar un detector de eventos GesturePerformedListener en una instancia de la clase
GestureOverlayView. La clase envolvente se declaró entonces para implementar tanto la interfaz
OnGesturePerformedListener y el método de devolución de llamada onGesturePerformed correspondiente
requerida por dicha interfaz. En el caso de que un gesto es detectado por el oyente, una llamada al método de
devolución de llamada onGesturePerformed se activa el sistema de ejecución Android.
La identificación de los gestos específicos

Cuando se detecta un gesto, el método de devolución de llamada onGesturePerformed se llama y pasa como
argumentos una referencia al objeto GestureOverlayView en la que se detectó el gesto, junto con un objeto
Gesto que contiene información sobre el gesto.
Con el acceso al objeto de gestos, el GestureLibrary puede ser utilizado para comparar el gesto detectado a las
contenidas en los gestos archivo previamente cargado en la aplicación. El GestureLibrary informa la
probabilidad de que el gesto realizado por el usuario coincide con una entrada en el archivo de gestos mediante
el cálculo de una puntuación de predicción para cada gesto. Una puntuación de predicción de 1,0 o superior es
generalmente aceptado para ser un buen partido entre un gesto almacenada en el archivo y la realizada por el
usuario en la pantalla del dispositivo.
Añadir Soporte de tarjetas SD a un AVD

Antes de la aplicación del constructor Gesto se puede utilizar para diseñar gestos en un emulador, el dispositivo
virtual se debe configurar con una tarjeta virtual SD en la que se guardará el archivo de gestos (esto no es
necesario cuando se utiliza un dispositivo Android física).
A los efectos de este ejemplo, la AVD creado en el capítulo titulado Creación de un dispositivo virtual de Android
(AVD) en Android estudio será modificado para añadir soporte de tarjetas SD usando el Administrador de
AVD. Esto puede ser lanzado desde una ventana principal proyecto existente a través de las Herramientas ->
Android -> opción de menú AVD Manager o desde la pantalla de bienvenida al seleccionar Configurar ->
Administrador de AVD en el menú de inicio rápido. En la pantalla del Administrador de dispositivos virtuales de
Android resultante, seleccione un AVD (en este caso el emulador Nexus7) y haga clic en el botón Editar ... para
mostrar el cuadro de diálogo de edición como se ilustra en la Figura 23-1.
En el diálogo de configuración, escriba un valor de 10 MiB en el campo Tamaño de la sección Tarjeta SD del
diálogo y, a continuación, haga clic en el botón Aceptar para confirmar los cambios. La AVD ahora tiene
almacenamiento SD Card virtual disponible para almacenar el archivo de gestos.
Figura 23-1
Creación y ejecución de la Application Builder Gesto

La aplicación Constructor Gesto se incluye por defecto con el perfil emulador AVD para la mayoría de las
versiones del SDK. No es, sin embargo, preinstalado en la mayoría de los dispositivos Android físicas. Si la
utilidad es pre-instalado, aparecerá en la lista junto con el resto de aplicaciones instaladas en el dispositivo o
instancia AVD. En el caso de que no está instalado, se incluye el código fuente de la utilidad entre los ejemplos
de SDK de Android estándar y por lo tanto puede ser importado como un proyecto Android Estudio y compilado
y ejecutado en cualquier dispositivo o emulador de Android.
Para instalar y construir la utilidad GestureBuilder, comenzar con la instalación de los ejemplos de SDK. Para
ello, abra el Administrador de Android SDK seleccionando Herramientas -> Android -> opción de barra de menú
Administrador SDK desde la ventana principal del proyecto.
Una vez que el administrador haya cargado, localizar las muestras para el paquete SDK situado debajo de la
sección para la versión de Android para el que usted está desarrollando actualmente (por ejemplo Android 4.4.2
(API 19)). Si el paquete no está instalado, establezca la casilla junto al paquete y haga clic en el botón Instalar 1
Paquete para iniciar la instalación.
Una vez finalizada la instalación, los ejemplos de SDK se instalarán en el directorio siguiente (donde
<path_to_installation> representa la ubicación en el sistema donde se instaló originalmente Android Studio):
<Path_to_installation> / sdk / samples / android-19
El código fuente de la aplicación Generador de Gesto se encuentra dentro de este directorio en una carpeta
denominada GestureBuilder dentro de la subcarpeta legado.
Desde la ventana principal de Android Estudio en un proyecto existente (no es posible importar un proyecto
desde la pantalla de bienvenida Android Studio), seleccione Archivo -> Importar proyecto ... menú de opciones
y, en el cuadro de diálogo resultante, busque y seleccione el GestureBuilder carpeta dentro del directorio de
ejemplos de SDK y haga clic en Aceptar. Confirme el directorio de destino y haga clic en Siguiente seguido
Finalizar para aceptar la configuración predeterminada en la pantalla final. En este punto, Android Estudio
importará el proyecto en la carpeta designada y convertirlo para que coincida con el archivo de proyecto Android
Studio y construir la estructura.
Una vez importados, instale y ejecute la utilidad GestureBuilder en un dispositivo Android conectado al sistema
de desarrollo.
Creación de un archivo Gestos
Una vez que la solicitud Constructor Gesto ha cargado, se debe indicar que no hay gestos todavía no se ha
creado. Para crear un nuevo gesto, haga clic en el botón Agregar gesto situado en la parte inferior de la pantalla
del dispositivo, introduzca el nombre de Círculo Gesto en el cuadro de texto Nombre y luego "dibujar" un gesto
con un movimiento circular en la pantalla, como se ilustra en la Figura 23 -2. Suponiendo que el gesto aparece
como requerida (representada por la línea amarilla en la pantalla del dispositivo), haga clic en el botón Hecho
para añadir el gesto para el archivo de gestos:
Figura 23-2
Después de que el gesto se ha guardado, la aplicación Generador de Gesto mostrará una lista de gestos
definidos en la actualidad, lo que, en este punto, consistirá únicamente en la nueva Gesto Circle.
Repita el proceso de creación de gesto para agregar otro gesto al archivo. Esto debería implicar un gesto de dos
tiempos de la creación de una X en la pantalla el nombre X Gesto. Al crear gestos que implican múltiples golpes,
asegúrese de dejar el menor tiempo posible entre cada carrera para que el constructor sabe que los trazos son
parte de un mismo gesto. Una vez que este gesto se ha añadido, la lista dentro de la aplicación Constructor
gesto debe ser similar a la expuesta en la Figura 23-3:
Figura 23-3
Extraer el archivo Gestos de la tarjeta SD

Como cada gesto fue creado dentro de la aplicación Generador de Gesto, que esta en un archivo llamado
gestos ubicados en la tarjeta SD del emulador o dispositivo en el que la aplicación se ejecuta. Antes de este
archivo se puede agregar a un proyecto Android de estudio, sin embargo, debe primero ser extraída de la tarjeta
SD y se guarda en el sistema de archivos local. Esto se logra más fácilmente mediante el uso de la herramienta
de línea de comandos adb. Abra una ventana del símbolo del Terminal o Comando, por lo tanto, y ejecutar el
siguiente comando:
adb devices
En el caso de que el comando adb no se encuentra, consulte Configuración de un entorno de desarrollo Estudio
Android para orientación sobre sumando esto a la variable de entorno PATH del sistema.
Una vez ejecutado, el comando listará todos los dispositivos físicos activos e instancias AVD conectados al
sistema. La siguiente salida, por ejemplo, indica que tanto un dispositivo físico y un emulador de AVD se han
detectado en el sistema de equipo de desarrollo:

dispositivo emulador-5554
Dispositivo 74CE000600000001
Con el fin de tirar de los gestos archivo desde el emulador en el ejemplo anterior y colocarlo en el directorio de
trabajo actual de la ventana del símbolo del Terminal o Comando, necesitaría el siguiente comando para
ejecutar:
adb -s-emulador 5554 tirón / sdcard / gestos.
Alternativamente, el archivo de gestos se puede jalar de un dispositivo conectado a través de adb con el
comando siguiente (donde se utiliza la opción -d para indicar un dispositivo físico):
adb -d tirón / sdcard / gestos.
Una vez que el archivo de gestos ha sido creado y se quitó la tarjeta SD, que está listo para ser añadido a un
proyecto Android Studio como un archivo de recursos. El siguiente paso, por lo tanto, es crear un nuevo
proyecto.

Crear un nuevo proyecto en Android de estudio, entrar CustomGestures en el campo Nombre de la aplicación y
actividad en blanco denominada CustomGesturesActivity con una disposición correspondiente nombre
activity_custom_gestures.
Adición de los Gestos archivo al proyecto

Dentro de la ventana de la herramienta Android Proyecto de estudio, busque y haga clic en la carpeta res
(ubicado bajo CustomGestures -> aplicación -> src -> principal) y seleccione Nuevo -> directorio en el menú
resultante. En el cuadro de diálogo Nuevo directorio, introduzca prima como el nombre de la carpeta y haga clic
en el botón Aceptar. Uso de la utilidad de explorador de archivos apropiado para su tipo de sistema operativo,
localice el archivo de gestos previamente extraídos de la tarjeta SD y copiar y pegar en la carpeta nueva prima
en la ventana de herramientas del proyecto.

Este ejemplo de aplicación requiere una interfaz de usuario muy simple que consiste en una vista LinearLayout
con un GestureOverlayView en capas en la parte superior de la misma para interceptar cualquier gestos
realizados por el usuario. Localice los CustomGestures -> aplicación -> src -> principal -> res -> diseño ->
activity_custom_gestures.xml archivo y haga doble clic en él para cargarlo en la herramienta Diseñador.
Por defecto, Android Studio ha proporcionado un componente RelativeLayout como el elemento raíz del diseño
de la interfaz de usuario por lo que este tendrá que ser eliminado y reemplazado con un LinearLayout. Localice
la instancia RelativeLayout en el árbol de componentes, haga clic derecho sobre él y seleccione la opción
Eliminar en el menú emergente (Figura 23-4).
Figura 23-4
Una vez que el gerente RelativeLayout se ha eliminado de la presentación, haga clic en la (Vertical) Artículo
LinearLayout de la sección Diseños de la paleta de Diseñador y arrastre y suéltelo en el diseño de la pantalla del
dispositivo. Encienda la herramienta Diseñador de modo de texto utilizando la ficha Texto a lo largo del borde
inferior del panel y compruebe que coincide con el XML para el diseño que en el siguiente listado:
<LinearLayout
android: layout_height = "fill_parent"
xmlns: android = "http://schemas.android.com/apk/res/android">
</ LinearLayout>
Vuelva al modo Diseño, busque la sección de Expertos de la paleta y arrastrar y soltar un objeto
GestureOverlayView al lienzo de diseño. Seleccione la instancia GestureOverlayView en el diseño y el uso de
los paneles o de la barra de herramientas Diseñador botones Propiedades para cambiar el diseño: la anchura y
el diseño: altura propiedades a match_parent para que la vista se llena el espacio disponible.
Haga doble clic en la instancia GestureOverlayView y utilizar el panel de propiedades emergente para cambiar
el ID de @ + / Identificación del GOverlay. Cuando se haya completado, el archivo activity_custom_gestures.xml
debería decir lo siguiente:
<LinearLayout
android: weightSum = "1">
<Android.gesture.GestureOverlayView
android: id = "@ + / Identificación del GOverlay"
android: layout_gravity = "center_horizontal">
</android.gesture.GestureOverlayView>
</ LinearLayout>
Carga del archivo Gestos

Ahora que el archivo de gestos se ha añadido al proyecto, el siguiente paso es escribir algo de código para que
se cargue el archivo cuando la actividad se pone en marcha.Para los propósitos de este proyecto, el código para
lograr este se colocará en el método onCreate () de la clase CustomGesturesActivity situado en el archivo de
origen CustomGesturesActivity.java como sigue:
com.ebookfrenzy.customgestures paquete;
android.gesture.GestureLibraries de importación;
android.gesture.GestureLibrary importación;
android.gesture.GestureOverlayView importación;
android.gesture.GestureOverlayView.OnGesturePerformedListener importación;
public class CustomGesturesActivity extiende ActionBarActivity implementa

OnGesturePerformedListener {
privado gLibrary GestureLibrary;
@ Override
setContentView (R.layout.activity_custom_gestures);
gLibrary =
GestureLibraries.fromRawResource (esto, R.raw.gestures);
if (! gLibrary.load ()) {
acabado ();
}
}
.
.
.
}
Además de algunas directivas de importación necesarios, los cambios de código anteriores al método onCreate
() para crear una instancia de GestureLibrary llamado gLibrary y luego carga en ella el contenido del archivo de
gestos ubicado en la carpeta de recursos en bruto. La clase de actividad también se ha modificado para
implementar la interfaz OnGesturePerformedListener, que requiere la aplicación del método de devolución de
llamada onGesturePerformed (que se creó en una sección posterior de este capítulo).
Registrando el detector de eventos

Para que la actividad para recibir la notificación de que el usuario ha realizado un gesto en la pantalla, es
necesario registrar el detector de eventos OnGesturePerformedListener en la vista gLayout, una referencia a la
que se puede obtener utilizando el método findViewById como se indica en el siguiente código fragmento:
@ Override
gLibrary =
acabado ();
}
GestureOverlayView GOverlay =
(GestureOverlayView) findViewById (R.id.gOverlay);
gOverlay.addOnGesturePerformedListener (this);
}
Implementación del Método onGesturePerformed

Todo lo que queda antes de que una prueba de funcionamiento inicial de la aplicación se puede realizar es
poner en práctica el método de devolución de llamada OnGesturePerformed. Este es el método que se llama
cuando un gesto se realiza en el ejemplo GestureOverlayView:
com.ebookfrenzy.customgestures paquete;
android.gesture.GestureLibraries de importación;
android.gesture.GestureLibrary importación;
android.gesture.GestureOverlayView importación;
android.gesture.GestureOverlayView.OnGesturePerformedListener importación;
android.gesture.Prediction importación;
android.widget.Toast importación;
android.gesture.Gesture importación;
java.util.ArrayList importación;
public class CustomGesturesActivity extiende ActionBarActivity implementa

OnGesturePerformedListener {
privado gLibrary GestureLibrary;
@ Override
gLibrary =
acabado ();
}
GestureOverlayView GOverlay =
(GestureOverlayView) findViewById (R.id.gOverlay);
gOverlay.addOnGesturePerformedListener (this);
}
public void superposición onGesturePerformed (GestureOverlayView, Gesto

gesto) {
ArrayList <Predicción> predicciones =
gLibrary.recognize (gesto);
si (predictions.size ()> 0 && predictions.get (0) .score> 1,0) {
Acción String = predictions.get (0) .name;
Toast.makeText (esto, acción, Toast.LENGTH_SHORT) .show ();

}
}
.
.
.
}
Cuando un gesto en la vista de los objetos gráficos gesto es detectado por el tiempo de ejecución de Android, se
llama al método onGesturePerformed. Pasado a través de como argumentos son una referencia al objeto
GestureOverlayView en la que se detectó el gesto junto con un objeto de tipo gesto. La clase Gesto está
diseñado para contener la información que define un gesto específico (esencialmente una secuencia de puntos
cronometrados en la pantalla que representa la trayectoria de los trazos que componen un gesto).
El objeto se pasa a través de gestos con el método de reconocer () de nuestro ejemplo gLibrary, el propósito de
los cuales es comparar el gesto actual con cada gesto cargado desde los gestos presentar. Una vez que esta
tarea se ha completado, la reconocen () devuelve un objeto ArrayList que contiene un objeto de predicción para
cada comparación realizada. La lista está clasificada por orden desde el mejor partido (en la posición 0 de la
matriz) para lo peor. Contenido dentro de cada objeto de predicción es el nombre de la correspondiente gesto de
archivo de gestos y una puntuación de predicción que indica hasta qué punto coincide con el gesto actual.
El código en el método anterior, por lo tanto, lleva a la predicción en la posición 0 (el valor más cercano) se
asegura de que tiene una puntuación superior a 1,0 y luego muestra un mensaje de Toast (una clase de Android
diseñada para mostrar la notificación pop ups para el usuario) mostrando el nombre del gesto a juego.
Genere y ejecute la aplicación a ambos un emulador o en un dispositivo Android física y realizar los gestos
circulares y banda magnética en la pantalla. Cuando se realiza la notificación tostadas debería aparecer con el
nombre del gesto que se realizó. Tenga en cuenta, sin embargo, que al intentar realizar la X gesto que el gesto
no se reconoce. Además, tenga en cuenta que cuando se reconoce un gesto, se perfila en la pantalla con una
línea de color amarillo brillante, mientras que los gestos sobre el que la superposición es incierto aparecen como
una línea amarilla descolorida. Mientras útil durante el desarrollo, esto probablemente no es ideal para una
aplicación en el mundo real. Claramente, por lo tanto, todavía hay algunos más trabajo de configuración de
hacer.
Configuración del GestureOverlayView

Por defecto, el GestureOverlayView está configurado para mostrar las líneas amarillas durante gestos y
reconocer sólo gestos solo golpe. Gestos Multi-accidente cerebrovascular pueden ser detectados mediante el
establecimiento de la androide: propiedad gestureStrokeType al múltiple.
Del mismo modo, el color utilizado para dibujar reconocido y gestos no reconocidos se puede definir a través del
androide: gestureColor y android: propiedades uncertainGestureColor. Por ejemplo, para ocultar las líneas gesto
y reconocer gestos de varios trazos, modificar el archivo activity_custom_gestures.xml en el proyecto de ejemplo
como sigue:
<LinearLayout
android: weightSum = "1">
<Android.gesture.GestureOverlayView
android: id = "@ + / Identificación del GOverlay"
android: layout_gravity = "center_horizontal"
android: gestureColor = "# 00000000"
android: uncertainGestureColor = "# 00000000"
android: gestureStrokeType = "múltiple">
</android.gesture.GestureOverlayView>
</ LinearLayout>
Al volver a ejecutar la aplicación, los gestos deben ser ahora invisible (ya que se dibujan en blanco sobre el
fondo blanco de la vista LinearLayout).
Interceptar Gestos
El GestureOverlayView es, como se ha descrito anteriormente, una cubierta transparente que puede ser
colocado sobre la parte superior de otras vistas. Esto lleva a la pregunta de si los eventos interceptados por la
superposición gesto entonces deben ser transmitidos a las vistas subyacentes cuando un gesto ha sido
reconocido. Esto se controla a través del androide: propiedad eventsInterceptionEnabled de la instancia
GestureOverlayView. Cuando se define como true, los eventos de gestos no se pasan a las vistas subyacentes
cuando se reconoce un gesto. Esto puede ser un ajuste particularmente útil cuando se están realizando gestos
sobre una vista que podrían ser configurado para desplazarse en respuesta a ciertos gestos. Al establecer esta
propiedad en true evitará gestos también se interpreta como instrucciones para la vista subyacente para
desplazarse en una dirección particular.
La detección de gestos de pellizco

Antes de pasar por el manejo táctil de reconocimiento general y el gesto, en particular, el último tema de este
capítulo es el de la manipulación de los gestos de pellizco. Si bien es posible crear y detectar una amplia gama
de gestos utilizando los pasos descritos en las secciones anteriores de este capítulo es, de hecho, no es posible
detectar un gesto de pellizco (donde se utilizan dos dedos en un movimiento de estiramiento y pellizcos,
típicamente para acercar y alejar de una vista o imagen) utilizando las técnicas descritas hasta ahora.
El método más simple para detectar gestos de pellizco es utilizar la clase ScaleGestureDetector Android. En
términos generales, la detección de los gestos de pellizco implica los tres pasos siguientes:
1. Declaración de una nueva clase que implementa la interfaz SimpleOnScaleGestureListener incluyendo la
onScale requerido (), onScaleBegin () y onScaleEnd () los métodos callback. 2. Creación de una instancia de la
clase ScaleGestureDetector, pasando a través de una instancia de la clase creada en el paso 1 como
argumento. 3. Aplicación del método de devolución de llamada onTouchEvent () sobre la actividad que encierra
lo que, a su vez, llama al método onTouchEvent () de la clase ScaleGestureDetector. En el resto de este
capítulo, vamos a crear un ejemplo muy simple diseñado para demostrar la aplicación de reconocimiento de
gestos pizca.
Un gesto de pellizcar Ejemplo de proyecto

Crear un nuevo proyecto en Android de estudio, entrar PinchExample en el campo Nombre de la aplicación y
actividad en blanco denominada PinchExampleActivity con una disposición correspondiente llamado
activity_pinch_example.
Dentro del archivo activity_pinch_example.xml, busque el objeto TextView y haga doble clic en él para cambiar
el ID de myTextView.
Localice y cargue el archivo PinchExampleActivity.java en el editor de Android Studio y modificar el archivo de la
siguiente manera:
com.ebookfrenzy.pinchexample paquete;
android.view.ScaleGestureDetector importación;
android.view.ScaleGestureDetector.SimpleOnScaleGestureListener importación;
public class PinchExampleActivity extiende ActionBarActivity {
TextView scaleText;
ScaleGestureDetector scaleGestureDetector;
@ Override
setContentView (R.layout.activity_pinch_example);
scaleText = (TextView) findViewById (R.id.myTextView);
scaleGestureDetector =
nueva ScaleGestureDetector (esto,
nueva MyOnScaleGestureListener ());
}
@ Override
onTouchEvent public boolean (evento MotionEvent) {
scaleGestureDetector.onTouchEvent (evento);
return true;
}
public class MyOnScaleGestureListener extiende

SimpleOnScaleGestureListener {
@ Override
onScale public boolean (detector ScaleGestureDetector) {
flotar scaleFactor = detector.getScaleFactor ();
si (scaleFactor> 1) {
scaleText.setText ("Zoom Out");
} Else {
scaleText.setText ("Zoom In");
}
return true;
}
@ Override
onScaleBegin public boolean (detector ScaleGestureDetector) {
return true;
}
@ Override
public void onScaleEnd (detector ScaleGestureDetector) {
}
}
.
.
.
}
El código empieza por declarar variables TextView y ScaleGestureDetector. Una nueva clase llamada
MyOnScaleGestureListener se declara que se extiende la clase Android SimpleOnScaleGestureListener. Esta
interfaz requiere que tres métodos (onScale (), onScaleBegin () y onScaleEnd ()) ser realizados. En este caso, el
método onScale () identifica el factor de escala y muestra un mensaje en la vista de texto que indica el tipo de
gesto de pellizcar detectado.
Dentro del método onCreate (), se obtiene una referencia al objeto de vista de texto y se asigna a la variable
scaleText. A continuación, se crea una nueva instancia ScaleGestureDetector, pasando a través de una
referencia a la actividad envolvente y una instancia de nuestra nueva clase MyOnScaleGestureListener como
argumentos.Por último, un onTouchEvent () método de devolución de llamada se implementa para la actividad,
que simplemente llama al método del objeto ScaleGestureDetector correspondiente onTouchEvent (), pasando a
través del objeto MotionEvent como argumento.
Compila y ejecuta la aplicación en un dispositivo Android física y realizar pellizcos gestos en la pantalla, y señaló
que la vista Texto muestra tanto el zoom o alejar mensaje dependiendo del movimiento de pellizco.
Resumen
Un gesto es esencialmente el movimiento de puntos de contacto en una pantalla táctil que implican uno o más
golpes y puede ser utilizado como un método de comunicación entre el usuario y la aplicación. Android permite
gestos para ser diseñados utilizando la aplicación Generador de Gesto. Una vez creados, los gestos se pueden
guardar en un archivo de gestos y se cargan en una actividad en tiempo de ejecución de aplicaciones utilizando
la GestureLibrary.
Los gestos pueden ser detectados en áreas de la pantalla mediante la superposición de puntos de vista
existentes con instancias de la clase GestureOverlayView transparente e implementación de un detector de
eventos OnGesturePerformedListener. Utilizando el GestureLibrary, una lista clasificada de los partidos entre un
gesto realizado por el usuario y los gestos almacenados en un archivo gestos se puede generar, mediante una
puntuación de predicción para decidir si un gesto es un partido bastante cerca.
23 Introducción al uso de fragmentos en Android Estudio
A medida que avance a través de los capítulos de este libro será cada vez más evidente que muchos de los
conceptos de diseño detrás del sistema Android se concibieron con el objetivo de promover la reutilización de, y
la interacción entre los diferentes elementos que componen una aplicación. Una de esas áreas que será
explorado en este capítulo implica el uso de fragmentos. En este capítulo se ofrecerá una visión general de los
conceptos básicos de fragmentos en términos de lo que son y cómo pueden ser creados y utilizados dentro de
las aplicaciones. El siguiente capítulo trabajará a través de un tutorial diseñado para mostrar fragmentos en
acción cuando el desarrollo de aplicaciones en Android de estudio, incluida la aplicación de la comunicación
entre los fragmentos.
Qué es un fragmento?
Un fragmento es una sección modular autónomo de la interfaz de usuario de una aplicación y el comportamiento
correspondiente que puede ser embebido dentro de una actividad. Los fragmentos se pueden ensamblar para
crear una actividad durante la fase de diseño de la aplicación, y se añaden a, o se quitan de una actividad
durante la ejecución de la aplicación para crear una interfaz de usuario que cambia dinámicamente.
Los fragmentos sólo se pueden utilizar como parte de una actividad y no puede ser instanciada como elementos
aplicación independiente. Dicho esto, sin embargo, un fragmento puede ser pensado como un "sub-actividad"
funcional con su propio ciclo de vida similar a la de una actividad completa.
Los fragmentos se almacenan en forma de archivos de diseño XML y pueden ser añadidos a una actividad ya
sea mediante la colocación apropiada <fragmento> elementos de archivo de diseño de la actividad, o
directamente a través de código dentro de implementación de la clase de la actividad.
Antes de comenzar a utilizar fragmentos de una aplicación para Android, es importante tener en cuenta que los
fragmentos no se introdujeron a Android hasta la versión 3.0 del SDK de Android. Una aplicación que utiliza
fragmentos deben, por lo tanto, hacer uso del androide-support-v4 Android Biblioteca de compatibilidad con el
fin de ser compatible con las versiones de Android de mayor edad. Los pasos para lograr esto se tratarán en el
próximo capítulo, titulado Uso de fragmentos en Android Studio - Un Ejemplo .
Creación de un fragmento
Los dos componentes que componen un fragmento son un archivo de formato XML y una clase Java
correspondiente. El archivo de diseño XML para un fragmento lleva el mismo formato que un diseño para
cualquier otra disposición actividad y puede contener cualquier combinación y la complejidad de los
controladores de distribución y puntos de vista. El siguiente esquema XML, por ejemplo, es para un fragmento
que consta simplemente de un RelativeLayout con un fondo rojo que contiene un único TextView:

android: fondo = "@ / color rojo">
<TextView
android: text = "@ string / fragone_label_text"
</ RelativeLayout>
La clase correspondiente a ir con el diseño debe ser una subclase de la clase Fragmento Android. Si la solicitud
es para que sea compatible con los dispositivos que ejecutan versiones de Android anteriores a la versión 3.0, el
archivo de clase debe importar android.support.v4.app.Fragment. La clase debe, como mínimo, reemplazar el
método onCreateView (), que es responsable de cargar el diseño fragmento. Por ejemplo:
com.example.myfragmentdemo paquete;
android.support.v4.app.Fragment importación;
android.view.LayoutInflater importación;
android.view.ViewGroup importación;
public class FragmentOne extiende Fragmento {

@ Override
pública Vista onCreateView (LayoutInflater inflado,
Contenedor ViewGroup,
Bundle savedInstanceState) {
// Inflar el diseño de este fragmento
volver inflater.inflate (R.layout.fragment_one_layout,
contenedor, false);
}
}
Además del método onCreateView (), la clase también puede anular los métodos de ciclo de vida estándar.
Tenga en cuenta que con el fin de hacer que el fragmento anterior compatible con las versiones de Android
anteriores a la versión 3.0, la clase Fragmento de la biblioteca de soporte v4 se ha importado.
Una vez que se han creado la disposición fragmento y la clase, el fragmento está listo para ser utilizado dentro
de las actividades de aplicación.
Adición de un fragmento de una actividad utilizando el archivo XML

Layout
Los fragmentos pueden ser incorporados en una actividad ya sea por la escritura de código Java o mediante la
incorporación del fragmento en el archivo XML diseño de la actividad. Independientemente del enfoque utilizado,
un punto clave a tener en cuenta es que cuando la biblioteca de soporte se utiliza para la compatibilidad con
versiones de Android de mayor edad, las actividades que utilizan fragmentos deben implementarse como una
subclase de FragmentActivity lugar de la clase de actividad tradicional:
com.example.myfragmentdemo paquete;
android.support.v4.app.FragmentActivity importación;
public class FragmentDemoActivity extiende FragmentActivity {
@ Override
setContentView (R.layout.activity_fragment_demo);
}
@ Override
getMenuInflater (). inflar (R.menu.activity_fragment_demo,
menú);
return true;
}
}
Los fragmentos están incrustados en archivos de diseño de actividad utilizando el <fragmento> elemento. El
siguiente ejemplo de diseño incorpora el fragmento creado en la sección anterior de este capítulo en una
maquetación de la actividad:

herramientas: context = ". FragmentDemoActivity">
<Fragmento
android: id = "@ + / Identificación del fragment_one"
android: name = "com.example.myfragmentdemo.myfragmentdemo.FragmentOne"
herramientas de diseño: = "@ diseño / fragment_one_layout" />
</ RelativeLayout>
Las propiedades clave dentro de la <fragmento> elemento son androide: nombre, que debe hacer referencia a la
clase asociada con el fragmento, y las herramientas: diseño, lo que debe hacer referencia al archivo de recursos
XML que contiene la disposición del fragmento.
Una vez añadido a la disposición de una actividad, fragmentos se pueden ver y manipular dentro de la
herramienta Android Studio Designer. Figura 24-1, por ejemplo, muestra la disposición anterior con el fragmento
incrustado dentro Diseñador Android Estudio:
Figura 24-1
Adición y Gestión de Fragmentos de Código

La facilidad de la adición de un fragmento de una actividad a través de archivo de diseño XML de la actividad se
produce en el costo de la actividad no ser capaz de eliminar el fragmento en tiempo de ejecución. Con el fin de
lograr el control dinámico de fragmentos durante el tiempo de ejecución, estas actividades hay que añadir a
través del código. Esto tiene la ventaja de que los fragmentos se pueden añadir, eliminar e incluso hizo para
reemplazar el uno al otro de forma dinámica mientras la aplicación se está ejecutando.
Cuando se utiliza código para administrar fragmentos, el propio fragmento todavía consistirá en un archivo de
diseño XML y una clase correspondiente. La diferencia viene cuando se trabaja con el fragmento dentro de la
actividad de alojamiento. Hay una secuencia estándar de pasos cuando se añade un fragmento a una actividad
utilizando el código. Estos pasos son los siguientes:
1. Crear una instancia de la clase del fragmento.
2. Pasar argumentos adicionales a través de la intención a la clase.
3. Obtener una referencia a la instancia del gestor de fragmentos.
4. Llame al método beginTransaction () de la instancia del gestor de fragmento. Esto devuelve una instancia de
transacción fragmento.
5. Llame al método de la instancia de transacción fragmento add (), pasando por como argumentos el id de un
recurso de la opinión de que es contener el fragmento y la instancia de clase fragmento.
6. Llame al método commit () de la transacción fragmento.
El siguiente código, en aras de un ejemplo, añade un fragmento definido por la clase FragmentOne para que
aparezca en la vista de contenedor con un id de LinearLayout1:
FragmentOne firstFragment = new FragmentOne ();
firstFragment.setArguments (getIntent () getExtras ().);
FragmentManager fragManager = getSupportFragmentManager ();

FragmentTransaction transacción = fragManager.beginTransaction ();
transaction.add (R.id.LinearLayout1, firstFragment);

transaction.Commit ();
El código anterior se descompone cada paso en una declaración por separado a los efectos de claridad. Las
últimas cuatro líneas pueden, sin embargo, ser abreviados en una sola línea de código de la siguiente manera:
getSupportFragmentManager (). beginTransaction ()

.add (R.id.LinearLayout1, firstFragment) .commit ();
Una vez añadido a un recipiente, un fragmento posteriormente puede ser eliminado a través de una llamada al
método remove () de la instancia de transacción fragmento, pasando a través de una referencia a la instancia
fragmento que se va a quitar:
transaction.remove (firstFragment);
Del mismo modo, un fragmento puede ser reemplazado con otro por una llamada al método replace () de la
instancia de transacción fragmento. Esto toma como argumentos el id de la vista que contiene el fragmento y
una instancia del nuevo fragmento. El fragmento reemplazado también se puede colocar en lo que se conoce
como la pila hacia atrás para que se puede restaurar rápidamente en el caso de que el usuario se desplaza de
nuevo a él. Esto se logra mediante una llamada al método addToBackStack () del objeto de transacción
fragmento antes de hacer el commit () llamada al método:
FragmentTwo secondFragment = new FragmentTwo ();

transaction.replace (R.id.LinearLayout1, secondFragment);
transaction.addToBackStack (null);
transaction.Commit ();
Gestión de eventos Fragmento

Como se mencionó anteriormente, un fragmento es muy parecido a un sub-actividad con su propio diseño, clase
y ciclo de vida. Los componentes de visualización (como botones y vistas de texto) dentro de un fragmento son
capaces de generar eventos al igual que los de una actividad regular. Esto plantea la cuestión de qué clase
recibe un evento de una vista en un fragmento; el fragmento de sí mismo, o la actividad en el que se incluye el
fragmento. La respuesta a esta pregunta depende de cómo se declara el controlador de eventos.
En el capítulo titulado Una visión general y Android Estudio Ejemplo de Android Manejo de Eventos , se
discutieron dos enfoques para la gestión de eventos. El primer método consiste en configurar un detector de
eventos y el método de devolución de llamada en el código de la actividad. Por ejemplo:
// Código que se lleva a cabo cuando
// Se hace clic en el botón
}
}
);
En el caso de interceptar eventos de clic, el segundo enfoque implicó establecer el androide: propiedad onClick
en el archivo de diseño XML:
<Botón
android: onClick = "onClick"
android: text = "Haga clic en mí" />
La regla general para los eventos generados por una vista de un fragmento es que si el detector de eventos fue
declarado en la clase fragmento utilizando el enfoque de detector de eventos y el método de devolución de
llamada, entonces el evento será manejado por primera vez por el fragmento. Si el android: onClick se utiliza de
recursos, sin embargo, el evento se pasa directamente a la actividad que contiene el fragmento.
Ejecución Fragmento Comunicación

Una vez que uno o más fragmentos están incrustados dentro de una actividad, hay muchas posibilidades de que
alguna forma de comunicación deberá tener lugar tanto entre los fragmentos y la actividad y entre un fragmento
y otro. De hecho, los fragmentos no deben comunicarse directamente entre sí. Toda comunicación debe
realizarse a través de la actividad de encapsulación.
Para que una actividad para comunicarse con un fragmento, la actividad debe identificar el objeto fragmento a
través de la ID asignado a él usando el método findViewById (). Una vez obtenida esta referencia, la actividad
sólo puede llamar a los métodos públicos del objeto fragmento.
La comunicación en la otra dirección (de fragmento a la actividad) es un poco más complicada. En el primer
caso, el fragmento debe definir una interfaz de escucha, que se implementa a continuación, dentro de la clase
de actividad. Por ejemplo, el código siguiente declara una interfaz llamada ToolbarListener en una clase
fragmento llamado ToolbarFragment. El código también declara una variable en la que más adelante se
almacena una referencia a la actividad:
public class ToolbarFragment extiende Fragmento {
ToolbarListener activityCallback;
interfaz pública ToolbarListener {

onButtonClick void (posición int, String text) pública;
}
.
.
}
El código anterior dicta que cualquier clase que implemente la interfaz ToolbarListener también debe
implementar un método de devolución de llamada con nombre onButtonClick que, a su vez, acepta un entero y
una cadena como argumentos.
A continuación, el método onAttach () de la clase fragmento se necesita omitir e implementado. Este método es
llamado automáticamente por el sistema Android cuando el fragmento se ha inicializado y se asocia con una
actividad. El método se pasa una referencia a la actividad en la que se contiene el fragmento. El método debe
almacenar una referencia local a esta actividad y verificar que implementa la interfaz ToolbarListener:
@ Override
public void onAttach (actividad Actividad) {
super.onAttach (actividad);
try {
activityCallback = actividad (ToolbarListener);
} Catch (ClassCastException e) {
throw new ClassCastException (activity.toString ()
+ "Debe implementar ToolbarListener");
}
}
Tras la ejecución de este ejemplo, una referencia a la actividad se almacena en la variable activityCallback local
y una excepción será lanzada si esa actividad no implementa la interfaz ToolbarListener.
El siguiente paso es llamar al método de devolución de llamada de la actividad desde dentro del
fragmento. ¿Cuándo y cómo sucede esto es totalmente dependiente de las circunstancias en que la actividad
tiene que ser contactado por el fragmento. En aras de un ejemplo, el código siguiente llama al método de
devolución de llamada en la actividad cuando se hace clic en un botón:
public void buttonClicked (Ver vista) {
activityCallback.onButtonClick (arg1, arg2);
}
Todo lo que queda es modificar la clase de actividad para que se implemente la interfaz ToolbarListener. Por
ejemplo:
public class FragmentExampleActivity extiende implementos FragmentActivity

ToolbarFragment.ToolbarListener {
pública onButtonClick void (String arg1, arg2 int) {
// Implementar código para el método de devolución de llamada
}
.
.
}
Como podemos ver en el código anterior, la actividad declara que implementa la interfaz ToolbarListener de la
clase ToolbarFragment y luego procede a aplicar el método onButtonClick () como es requerido por la interfaz.
Resumen
Fragmentos proporcionan un poderoso mecanismo para la creación de módulos reutilizables de diseño de la
interfaz de usuario y el comportamiento de la aplicación, que, una vez creado, puede ser embebido en las
actividades. Un fragmento consiste en un archivo de diseño de interfaz de usuario y una clase. Los fragmentos
pueden ser utilizados en una actividad, ya sea mediante la adición del fragmento de archivo de diseño de la
actividad, o escribiendo código para administrar los fragmentos en tiempo de ejecución. Fragmentos añadido a
una actividad en el código pueden ser removidos y reemplazados dinámicamente en tiempo de ejecución. Toda
la comunicación entre los fragmentos se debe realizar a través de la actividad en que se enmarcan las
actividades.
Después de haber cubierto los fundamentos de fragmentos en este capítulo, el capítulo siguiente ( Usando
fragmentos en Android Studio - Un Ejemplo ) funcionará a través de un tutorial diseñado para reforzar las
técnicas descritas en este capítulo.
24 Usando fragmentos en Android Studio - Un Ejemplo

Como se indica en el capítulo anterior, fragmentos proporcionan un mecanismo conveniente para la creación de
módulos reutilizables de funcionalidad de la aplicación que consta de dos secciones de una interfaz de usuario y
el comportamiento correspondiente. Una vez creados, los fragmentos pueden ser incrustados dentro de las
actividades.
Después de haber explorado la teoría general de los fragmentos en el capítulo anterior, el objetivo de este
capítulo es el de crear un ejemplo de aplicación Android usando Android Estudio diseñado para demostrar los
pasos reales que participan tanto en la creación y el uso de fragmentos, y también implementar la comunicación
entre un fragmento y otro dentro de una actividad.
bre el Fragmento Ejemplo de Aplicación

La aplicación creada en este capítulo consistirá en una sola actividad y dos fragmentos. La interfaz de usuario
para el primer fragmento contendrá una barra de herramientas de tipo consisten en una vista EditarTexto, un
SeekBar y un botón, todos contenidos dentro de una vista RelativeLayout. El segundo fragmento consistirá
únicamente en un objeto TextView, también contenida dentro de una vista RelativeLayout.
Los dos fragmentos se integrarán dentro de la actividad principal de la aplicación y de comunicaciones
implementada de forma que cuando se pulsa el botón en el primer fragmento, el texto entró en la vista
EditarTexto aparecerá en el TextView del segundo fragmento usando un tamaño de fuente dictada por la
posición de la SeekBar en el primer fragmento.
Dado que esta solicitud está destinada a trabajar en las versiones anteriores de Android, también será necesario
hacer uso de la biblioteca de soporte Android apropiado.

Crear un nuevo proyecto en Android de estudio, entrar FragmentExample en el campo Nombre de la aplicación
y ebookfrenzy.com como el ajuste de dominio de la empresa antes de hacer clic en el botón Siguiente.
actividad en blanco denominada FragmentExampleActivity con una disposición correspondiente llamado
activity_fragment_example.
Crear el primer fragmento Layout

El siguiente paso es crear la interfaz de usuario para el primer fragmento que se utilizará dentro de nuestra
actividad.
Esta interfaz de usuario, por supuesto, residir en un archivo de formato XML para comenzar navegando a la
carpeta de diseño situado bajo FragmentExample -> aplicación -> src -> principal -> res en la ventana de
herramientas del proyecto. Una vez localizado, haga clic en la entrada de diseño y seleccione Nuevo -> opción
del menú archivo de recursos de diseño como se ilustra en la Figura 25-1:
Figura 25-1
En el cuadro de diálogo resultante, nombre el toolbar_fragment diseño y cambiar el elemento raíz de

LinearLayout a RelativeLayout antes de hacer clic en Aceptar para crear el nuevo archivo de recursos.
El nuevo archivo de recursos aparecerá dentro de la herramienta Diseñador listos para ser diseñado. Cambie el
Diseñador para el modo de texto y modificar el XML para que se lea como se indica en el siguiente listado para
agregar tres nuevos elementos de la vista en el diseño:
<RelativeLayout
android: layout_height = "match_parent">
<Botón
android: layout_below = "@ + / Identificación del seekBar1"
android: layout_marginTop = "17dp"
android: text = "texto del cambio" />
<EditarTexto
android: id = "@ + / Identificación del editText1"
android: ems = "10"
android: InputType = "text">
<RequestFocus />
</ EditarTexto>
<SeekBar
android: id = "@ + / Identificación del seekBar1"
android: layout_below = "@ + / Identificación del editText1"
android: layout_marginTop = "14dp" />
</ RelativeLayout>
Una vez que se han realizado los cambios, cambiar la herramienta Diseñador de nuevo a modo de
diseño. Seleccione la vista botón y haga clic en el icono de la bombilla seguido del mensaje I18N para mostrar el
diálogo Extract Resource. Nombre del button_text recurso y haga clic en Aceptar para crear un recurso de
cadena para el botón.
Al completar estos pasos, el diseño de la interfaz de usuario debe ser similar a la de la Figura 25-2:
Figura 25-2
Con la disposición para el primer fragmento implementado, el siguiente paso es crear una clase para ir con ella.
Crear el primer fragmento Clase

Además de un diseño de interfaz de usuario, un fragmento también tiene que tener una clase asociada con él
para hacer el trabajo real detrás de las escenas. Añadir una clase para este fin al proyecto desplegando el
FragmentExample -> aplicación -> src -> principal -> carpeta java bajo el proyecto FragmentExample en la
ventana de herramientas del proyecto y hacer clic derecho sobre el nombre del paquete dado al proyecto
cuando era creado (en este caso com.ebookfrenzy.fragmentexample). En el menú que aparece, seleccione la
nueva opción -> Java Class. En el cuadro de diálogo Crear nueva clase resultando, nombre el ToolbarFragment
clase y haga clic en Aceptar para crear la nueva clase.
Una vez que la clase se ha creado, se debe, por defecto, aparecerá en el panel de edición en el que se lea
como sigue:
com.ebookfrenzy.fragmentexample paquete;
/ **
* Creado por <nombre> el <fecha>.
* /
public class ToolbarFragment {
}
Por el momento, los únicos cambios en esta clase son para añadir algunas directivas de importación y
reemplazar el método onCreateView () para asegurarse de que el archivo de diseño se infla y se visualiza
cuando se utiliza el fragmento dentro de una actividad. La declaración de la clase también debe indicar que la
clase amplía la clase Fragmento Android:
public class ToolbarFragment extiende Fragmento {
@ Override
Contenedor ViewGroup, Bulto
savedInstanceState) {

Ver view = inflater.inflate (R.layout.toolbar_fragment,
contenedor, false);
vista regresar;
}
}
Más adelante en este capítulo, se agregará más funcionalidad a esta clase. Antes de eso, sin embargo, tenemos
que crear el segundo fragmento.
La creación de la Segunda Fragmento Layout

Añadir un segundo archivo nuevo recurso diseño XML Android al proyecto, la selección una vez más un
RelativeLayout como el elemento raíz. Nombre del text_fragment diseño y haga clic en Aceptar. Cuando las
cargas de diseño en la herramienta de diseño, cambiar al modo de texto y modificar el código XML para agregar
un TextView a la disposición fragmento de la siguiente manera:

android: layout_height = "match_parent">
<TextView
android: text = "Fragmento Dos"
</ RelativeLayout>
Una vez que se han realizado los cambios XML, volver al modo Diseño, seleccione el componente TextView y
haga clic en el icono de la bombilla seguido del mensaje I18N para mostrar el diálogo Extract Resource. Nombre
del text_label recurso y haga clic en Aceptar para crear un recurso de cadena para el botón. Al completar estos
pasos, el diseño de la interfaz de usuario para este segundo fragmento debe ser similar a la de la Figura 25-3:
Figura 25-3
Al igual que con el primer fragmento, éste también tendrá que tener una clase asociada a ella. Despliegue la
categoría src bajo el proyecto FragmentExample (si no está ya desplegado) en la ventana de herramientas del
proyecto y haga clic derecho en el nombre del paquete. En el menú que aparece, seleccione la nueva opción ->
Java Class. Nombre del TextFragment fragmento y haga clic en Aceptar para crear la clase.
Edite el nuevo archivo de clase TextFragment.java y modificarlo para implementar el método onCreateView () y
designar a la clase como una ampliación de la clase Android Fragmento:
public class TextFragment extiende Fragmento {
@ Override
Ver view = inflater.inflate (R.layout.text_fragment,
contenedor, false);
vista regresar;
}
}
Ahora que la estructura básica de los dos fragmentos se ha implementado, que están listos para ser embebido
en la actividad principal de la aplicación.
Adición de los fragmentos de la Actividad

La actividad principal de la aplicación tiene asociado un archivo de formato XML denominado
activity_fragment_example.xml. A los efectos de este ejemplo, se añadirán los fragmentos a la actividad
mediante el <fragmento> elemento dentro de este archivo. Uso de la ventana de la herramienta de proyecto,
vaya a la FragmentExample -> aplicación -> src -> principal -> res -> sección de diseño del proyecto
FragmentExample y haga doble clic en el archivo activity_fragment_example.xml para cargar en la herramienta
Android Studio Designer.
Con la herramienta de diseño en modo de diseño, seleccionar y eliminar el objeto TextView defecto de la
disposición y desplácese hacia abajo la paleta hasta que la sección personalizada está a la vista. Haga clic en el
<fragmento> entrada para mostrar una lista de los fragmentos disponibles dentro del proyecto actual como se
ilustra en la Figura 25-4:
Figura 25-4
Seleccione la entrada ToolbarFragment de la lista y haga clic en el botón Aceptar para cerrar el diálogo
Fragmentos. Mueva el puntero del ratón al borde superior central del área de disposición de los padres para que
se muestren las opciones centerHorizontal y alignParentTop (Figura 25-5).
Figura 25-5
Una vez colocado correctamente, liberar el fragmento para añadirlo a la disposición. Una vez añadido, un panel
de mensaje aparecerá (Figura 25-6) lo que indica que la herramienta Diseñador necesita saber qué fragmento
para mostrar durante la sesión de vista previa. Visualizar el fragmento ToolbarFragment haciendo clic en el uso
@ diseño / toolbar_fragment enlace dentro del mensaje:
Figura 25-6
Haga clic en el <fragmento> entrada en la sección de Uso de la paleta, una vez más, esta vez seleccionando la
entrada TextFragment desde el diálogo fragmento antes de hacer clic en el botón Aceptar. Mueva el puntero del
ratón hasta el centro de la distribución de modo que las propiedades centerHorizontal y centerVertical se activan
y liberar el fragmento. Cuando aparezca el mensaje de representación, haga clic en la opción Usar @ diseño /
text_fragment. Tenga en cuenta que los fragmentos son ahora visibles en la disposición como se demuestra en
la Figura 25-7:
Figura 25-7
Antes de proceder con el siguiente paso, haga doble clic en la instancia TextFragment en el diseño y, en el
panel resultante, cambiar el id del fragmento de @ + / Identificación del text_fragment.
Hacer la barra de herramientas Fragmento Hable con la Actividad

Cuando el usuario toca el botón de la barra de herramientas de fragmento, la clase fragmento va a necesitar
para conseguir el texto desde el punto de vista EditarTexto y el valor actual de la SeekBar y enviarlos al
fragmento de texto. Como se describe en Introducción al uso de fragmentos en Android Estudio , fragmentos no
deben comunicarse entre sí directamente, en lugar de utilizar la actividad en la que están inmersos como
intermediario. El primer paso en este proceso es para asegurarse de que el fragmento de la barra de
herramientas responde a la tecla que se ha pulsado. También tenemos que poner en práctica algo de código
para no perder de vista el valor de la opinión de SeekBar. A los efectos de este ejemplo, vamos a implementar
estos oyentes dentro de la clase ToolbarFragment. Seleccione el archivo ToolbarFragment.java y modificarlo
para que se lea como se muestra en el siguiente listado:
android.widget.SeekBar importación;
android.widget.SeekBar.OnSeekBarChangeListener importación;
public class ToolbarFragment extiende Fragmento implementa OnSeekBarChangeListener

{
static int privado seekvalue = 10;

EditarTexto EditarTexto estática privada;
@ Override
Contenedor ViewGroup, Bulto
savedInstanceState) {
contenedor, false);
EditarTexto = (EditarTexto) view.findViewById (R.id.editText1);

última SeekBar seekbar =
(SeekBar) view.findViewById (R.id.seekBar1);
seekbar.setOnSeekBarChangeListener (this);
botón Botón final =

(Button) view.findViewById (R.id.button1);
button.setOnClickListener (nuevo View.OnClickListener () {
buttonClicked (v);
}
});
vista regresar;
}
@ Override
public void onProgressChanged (SeekBar seekBar, int progreso,
boolean fromuser) {
seekvalue = progreso;
}
@ Override
public void onStartTrackingTouch (SeekBar arg0) {
@ Override
public void onStopTrackingTouch (SeekBar arg0) {
}
}
Antes de continuar, tenemos que tener un poco de tiempo para explicar los cambios en el código de arriba. En
primer lugar, la clase se declara como la implementación de la interfaz OnSeekBarChangeListener. Esto se
debe a que la interfaz de usuario contiene una instancia de SeekBar y el fragmento necesita recibir
notificaciones cuando el usuario desliza la barra para cambiar el tamaño de la fuente. Implementación de la
interfaz OnSeekBarChangeListener requiere que se apliquen los métodos onProgressChanged (),
onStartTrackingTouch () y onStopTrackingTouch (). Estos métodos se han aplicado, pero sólo el método
onProgressChanged () es realmente necesario para realizar una tarea, en este caso almacenar el nuevo valor
en un llamado seekvalue variable que ha sido declarado al comienzo de la clase. También declarado es una
variable en la que almacenar una referencia al objeto EditarTexto.
El método onCreateView () se ha modificado para obtener referencias al EditarTexto, SeekBar y puntos de vista
de los botones en el diseño. Una vez se ha obtenido una referencia al botón se utiliza para establecer un
OnClickListener en el botón que está configurado para llamar a un método llamado buttonClicked () cuando se
detecta un evento de clic. También entonces se implementa este método, aunque en este punto que no hace
nada.
La siguiente fase de este proceso es establecer el oyente que permitirá el fragmento para llamar a la actividad
cuando se hace clic en el botón. Esto sigue el mecanismo descrito en el capítulo anterior:
public class ToolbarFragment extiende Fragmento implementa OnSeekBarChangeListener

{
static int privado seekvalue = 10;

EditarTexto EditarTexto estática privada;
ToolbarListener activityCallback;
interfaz pública ToolbarListener {
onButtonClick void (posición int, String text) pública;
}
@ Override
public void onAttach (actividad Actividad) {
super.onAttach (actividad);
try {
activityCallback = actividad (ToolbarListener);
} Catch (ClassCastException e) {
throw new ClassCastException (activity.toString ()
+ "Debe implementar ToolbarListener");
}
}
@ Override
Contenedor ViewGroup, Bulto savedInstanceState) {

contenedor, false);
EditarTexto = (EditarTexto) view.findViewById (R.id.editText1);

última SeekBar seekbar =
(SeekBar) view.findViewById (R.id.seekBar1);
seekbar.setOnSeekBarChangeListener (this);
botón Botón final =

(Button) view.findViewById (R.id.button1);
button.setOnClickListener (nuevo View.OnClickListener () {
buttonClicked (v);
}
});
vista regresar;
}

activityCallback.onButtonClick (seekvalue,
. edittext.getText toString () ());
}
.
.
.
}
La implementación anterior resultará en un método llamado onButtonClick () que pertenece a la clase de

actividad que se llama cuando se hace clic en el botón por el usuario. Todo lo que queda, por lo tanto, es
declarar que la clase de actividad implementa la interfaz ToolbarListener recién creado y para poner en práctica
el método onButtonClick ().
Desde la Biblioteca de compatibilidad Android está siendo utilizado para el apoyo fragmento en las versiones de
Android anteriores, la actividad también se debe cambiar a la subclase de FragmentActivity lugar de
ActionBarActivity. La combinación de estos requisitos juntos los resultados en el siguiente archivo
FragmentExampleActivity.java modificado:
android.support.v4.app.FragmentActivity importación;
public class FragmentExampleActivity extiende FragmentActivity implementa
ToolbarFragment.ToolbarListener {
@ Override
setContentView (R.layout.activity_fragment_example);
}
public void onButtonClick (int tamaño_fuente, texto String) {
}
.
.
.
}
Con los cambios de código en su estado actual, el fragmento de la barra de herramientas detectará cuando el
botón se hace clic por el usuario y llamar a un método de la actividad pasa por el contenido del campo
EditarTexto y la configuración actual de la vista SeekBar. Ahora es el trabajo de la actividad de comunicarse con
el fragmento de texto y pasar a lo largo de estos valores para que el fragmento se puede actualizar el objeto
TextView en consecuencia.
Hacer la Actividad Hable con el fragmento de texto

Como se describe en Introducción al uso de fragmentos en Android Estudio , una actividad puede comunicarse
con un fragmento mediante la obtención de una referencia a la instancia de clase fragmento y luego llamar a los
métodos públicos en el objeto. Por lo tanto, dentro de la clase TextFragment ahora vamos a poner en práctica
un método público nombrados changeTextProperties () que toma como argumentos un entero para el tamaño de
la fuente y una cadena para el nuevo texto que se mostrará.El método usará estos valores para modificar el
objeto TextView. En el panel de edición Android de estudio, localizar y modificar el archivo TextFragment.java
añadir este nuevo método y para agregar código al método onCreateView () para obtener el ID del objeto
TextView:
public class TextFragment extiende Fragmento {
TextView TextView estática privada;
@ Override
Ver view = inflater.inflate (R.layout.text_fragment,
contenedor, false);
TextView = (TextView) view.findViewById (R.id.textView1);
vista regresar;
}
changeTextProperties public void (int tamaño_fuente, texto String)

{
textview.setTextSize (tamaño_fuente);
textview.setText (texto);
}
}
Cuando el fragmento TextFragment se colocó en el diseño de la actividad, se le dio un ID de text_fragment. El
uso de este ID, ahora es posible para la actividad para obtener una referencia a la instancia fragmento y llamar a
los changeTextProperties () en el objeto. Editar el archivo FragmentExampleActivity.java y modificar el método
onButtonClick () como sigue:
public void onButtonClick (int tamaño_fuente, texto String) {
TextFragment textFragment =
(TextFragment)
. getSupportFragmentManager () findFragmentById (R.id.text_fragment);
textFragment.changeTextProperties (tamaño_fuente, texto);

}
Con la codificación para este proyecto ha finalizado, la última tarea que queda es ejecutar la aplicación. Cuando
se inicia la aplicación, la actividad principal se iniciará y, a su vez, crear y mostrar los dos fragmentos. Cuando el
usuario toca el botón de la barra de herramientas de fragmento, el método onButtonClick () de la actividad será
llamado por el fragmento de la barra de herramientas y aprobó el texto de la vista EditarTexto y el valor actual
de la SeekBar. La actividad será entonces llamar a los changeTextProperties () método del segundo fragmento,
que modificará el TextView para reflejar el nuevo texto y tamaño de fuente:
Figura 25-8
Resumen
El objetivo de este capítulo ha sido la de trabajar a través de la creación de un proyecto de ejemplo destinado
específicamente para demostrar los pasos involucrados en el uso de fragmentos dentro de una aplicación
Android. Los temas cubiertos incluyen el uso de la Biblioteca de compatibilidad de Android para la
compatibilidad con versiones de Android anteriores a la introducción de fragmentos, la inclusión de fragmentos
dentro de un diseño de la actividad y la puesta en práctica de la comunicación inter-fragmento.
25 Android estudio Maestro / Detalle Flujo Tutorial
Una comprensión clara de cómo utilizar fragmentos (como se indica en los capítulos anteriores) es esencial para
poder hacer uso de la plantilla de flujo de maestro / detalle. En este capítulo se aplicará ninguna de estas
habilidades para explicar el concepto de diseño de la interfaz de usuario maestro / detalle antes de explorar en
detalle los elementos que conforman la plantilla de flujo de maestro / detalle incluido con Android Studio. Por
último, un ejemplo de aplicación se creará que muestra los pasos involucrados en la modificación de la plantilla
a las necesidades específicas de los desarrolladores de aplicaciones.
Android Maestro / Detalle de Flujo

Un flujo de maestro / detalle es un concepto de diseño de interfaz mediante el cual se muestra una lista de
elementos (en adelante, la lista maestra) para el usuario. Al seleccionar un elemento de la lista, la información
adicional relativa a ese artículo se presenta al usuario dentro de un panel de detalles. Una aplicación de correo
electrónico podría, por ejemplo, consistir en una lista maestra de mensajes recibidos consistentes en la dirección
del remitente y el asunto del mensaje. Tras la selección de un mensaje de la lista principal, el cuerpo del
mensaje de correo electrónico aparecería en el panel de detalles.
El tablet de tamaño pantallas de dispositivos Android, la lista maestra aparece en un panel vertical estrecha a lo
largo del borde izquierdo de la pantalla. El resto de la pantalla está dedicada al panel de detalle en un acuerdo
denominado modo de dos paneles. Figura 26-1, por ejemplo, muestra el detalle / arreglo de dos paneles
principal con tres elementos maestros cotizadas y el contenido del artículo tres que aparecen en el panel de
detalle:
Figura 26-1
El más pequeño, teléfono dimensionado dispositivos Android, la lista maestra ocupa toda la pantalla y el panel
de detalles aparece en una pantalla separada que aparece cuando se hace una selección de la lista
principal. En este modo, la pantalla de detalle incluye una barra de entrada de acción para volver a la lista
principal. Figura 26-2, por ejemplo, ilustra tanto la maestra y detalle pantallas para la misma lista de tres punto
en una pantalla de teléfono 4 ":
Figura 26-2
Creación de un maestro / detalle de Flujo de Actividad

En la siguiente sección de este capítulo, los diferentes elementos que componen la plantilla de flujo de maestro /
detalle serán cubiertos con algún detalle. Esto se logra mejor mediante la creación de un proyecto mediante el /
plantilla Flujo Detalle Maestro utilizar mientras se trabaja a través de la información. Este proyecto,
posteriormente, ser utilizado como la base para el tutorial al final del capítulo.
Crear un nuevo proyecto en Android de estudio, entrar MasterDetailFlow en el campo Nombre de la aplicación y
mínimo: Android 2.2 (Froyo).
Cuando la pantalla de configuración de la actividad del cuadro de diálogo Nuevo proyecto aparece, seleccione la
opción Master Flow / detalle como se ilustra en la Figura 26 325 3 antes de hacer clic en Siguiente una vez más:
Figura 26-3
La siguiente pantalla (Figura 26-4) ofrece la posibilidad de configurar los objetos que se mostrarán dentro de la
actividad de maestro / detalle. En el tutorial más adelante en este capítulo, la lista maestra contendrá una serie
de nombres de sitios web, y que, cuando se selecciona, se carga el sitio web elegido en una vista web en el
panel de detalles. Con estos requisitos en mente, establezca el campo Objeto Clase a "Sitio Web" y el objeto
Kind Plural y ajustes título a "sitios web".
Figura 26-4
Por último, haga clic en Finalizar para crear el nuevo Maestro / proyecto de aplicación basado Detalle Flow.
La anatomía del Maestro / Detalle Plantilla de Flujo

Una vez que un nuevo proyecto ha sido creado con la plantilla de flujo de maestro / detalle, una serie de
archivos de recursos de Java y de diseño XML se habrá creado automáticamente. Es importante obtener una
comprensión de estas diferentes archivos con el fin de ser capaz de adaptar la plantilla a las necesidades
específicas. Una revisión del proyecto dentro de la ventana de la herramienta Android Proyecto Estudio revelará
los siguientes archivos, donde <kind_name> se sustituye por el nombre de clase de objeto que se especificó
cuando se creó el proyecto (este ser "Sitio Web" en el caso del ejemplo MasterDetailFlow proyecto):
 <Kind_name> ListActivity.java - Esta es la actividad principal del proyecto, cuyo objetivo es mostrar
la lista maestra para el usuario (la disposición de que se almacena en el archivo activity_ <kind_name>
_list.xml recurso fragmento XML) . Si la clase detecta que la pantalla es suficientemente grande para
soportar el modo de dos paneles, una instancia de la <kind_name> _list fragmento del activity_
<kind_name> _twopane.xml archivo se crea y se muestra, de lo contrario, la instancia que figura en el
activity_ < kind_name> se utiliza archivo _list.xml. Esta clase también implementa y configura el método de
devolución de llamada onItemSelected () que se llama cuando el usuario realiza una selección de la lista
principal. Es la responsabilidad de este método para crear y mostrar un ejemplo del panel de detalle.En el
caso del modo de dos paneles, el panel de detalles está a cargo de la creación de una instancia de la
<kind_name> clase DetailFragment y agregarlo a la actividad actual. En las pantallas de dispositivos más
pequeños, esta vez involucra el lanzamiento de una segunda actividad en la forma de la etiqueta
<kind_name> clase DetailActivity (que luego, a su vez, crear una instancia de la clase <kind_name>
DetailFragment).
 activity_ <kind_name> _twopane.xml - Contiene tanto el <kind_name> _list fragmento lista maestra
y <kind_name> _detail_container FrameLayout declaraciones para el panel de detalles que se utilizará
cuando la aplicación se ejecuta en un dispositivo de pantalla lo suficientemente grande como para soportar
el modo de dos paneles.
 activity_ <kind_name> _list.xml - El archivo de recursos de diseño XML que contiene el

<kind_name> fragmento _list para la lista principal que se utilizará en las pantallas demasiado pequeñas
como para soportar el modo de dos paneles.
 <Kind_name> ListFragment.java - La clase Java que acompaña al activity_ <kind_name> _list.xml
archivo de recursos fragmento. Esta clase contiene una serie de métodos que sirven para identificar y
poner de relieve actual selección lista principal del usuario.
 <Kind_name> DetailActivity.java - La clase Java que representa la actividad para el panel de

detalles para su uso en dispositivos demasiado pequeños para manejar el modo de dos paneles. Esta clase
crea una instancia de la <kind_name> clase FragmentDetail y muestra el <kind_name> _detail_container
FrameLayout contenedor declarado en la _detail.xml archivo activity_ <kind_name>.
 activity_ <kind_name> _detail.xml - La disposición de recursos XML que acompaña a la

<kind_name> ActivityDetail.java archivo de clase utilizado en dispositivos de pantalla pequeña. Por defecto,
este contiene una instancia FrameLayout al que se añadirá elementos de la interfaz de usuario declarados
por el <kind_name> FragmentDetail clase.
 <Kind_name> DetailFragment.java - La clase Java que acompaña al fragment_ <kind_name>

_detail.xml archivo de recursos XML. El código de este método carga los datos asociados con la lista
maestra y muestra el contenido de la <kind_name> _detail.xml archivo fragment_ al usuario.
 fragment_ <kind_name> _detail.xml - El <kind_name> _detail interfaz de usuario del panel de detalle
que se muestra en el método de la clase <kind_name> DetailFragment onCreateView (). Por defecto, este
contiene una sola instancia de objeto TextView y se utiliza tanto en dos-panel y los modos de pantalla
pequeña.
 DummyContent.java - un archivo de clase destinado a proporcionar datos de la muestra para la

plantilla. Esta clase o bien se puede modificar para satisfacer las necesidades de la aplicación, o sustituido
en su totalidad. Por defecto, el contenido proporcionado por esta clase consiste simplemente en una serie
de elementos de cuerda.
Dos archivos adicionales también son de interés puramente por el bien de la comprensión de cómo la aplicación
es capaz de identificar si se debe utilizar el modo de dos paneles o no. Estos archivos son res / valores-
grandes / refs.xml y res / valores-sw600dp / refs.xml.
Como se describe con mayor detalle en el capítulo titulado Manejo de diferentes dispositivos y pantallas de
Android, cada proyecto de aplicación tiene varios conjuntos de recursos que se dirigen a diferentes tamaños de
pantalla. En tiempo de ejecución, el sistema Android utiliza automáticamente el conjunto de recursos que más
se acerque el tamaño de visualización física del dispositivo. Los valores grandes recursos y valores sw600dp
son, por supuesto, que se utiliza en los dispositivos con pantallas más grandes. Los archivos ref.xml en estas
carpetas simplemente declaran un alias que hace que los diseños modo de dos paneles a utilizar:
<Nombre de elemento = tipo "activity_item_list" = "layout"> @ diseño /

activity_item_twopane </ item>
Modificación del Maestro / Detalle Plantilla de Flujo

Mientras que la estructura de la plantilla de flujo de maestro / detalle puede parecer confuso al principio, los
conceptos quedarán más claras como la plantilla predeterminada se modifica en el resto de este capítulo. Como
resultará evidente, gran parte de la funcionalidad proporcionada por la plantilla puede permanecer sin cambios
durante muchos requisitos de implementación maestro / detalle.
En el resto de este capítulo, el proyecto MasterDetailFlow será modificado de tal manera que la lista principal
muestra una lista de nombres de sitios web y el panel de detalles alterado para contener un objeto WebView
lugar del TextView actual. Cuando un sitio web se ha seleccionado por el usuario, la página web
correspondiente, posteriormente, cargar y mostrar en el panel de detalles.
Cambiar el modelo de contenido

El contenido para el ejemplo en su forma actual se define por el archivo de clase DummyContent. Comienza, por
lo tanto, al seleccionar el archivo DummyContent.java (ubicado en la ventana de la herramienta de proyecto en
el MasterDetailFlow -> aplicación -> src -> principal -> Java -> com.ebookfrenzy.masterdetailflow -> carpeta
ficticio) y revisar el código. En la parte inferior del archivo es una declaración de una clase llamada DummyItem
que actualmente es capaz de almacenar dos objetos String que representa una cadena de contenido y un ID. El
proyecto actualizado, por otro lado, será necesario cada objeto elemento para contener una cadena de ID, una
cadena para el nombre del sitio web, y una cadena de la dirección URL correspondiente del sitio web. Para
agregar estas características, modificar la clase DummyItem para que se lea de la siguiente manera:
clase public static DummyItem {

Identificación del public String;
website_name public String;
website_url public String;
DummyItem pública (id String, String website_name,

Website_url String)
{
this.id = id;
this.website_name = website_name;
this.website_url = website_url;
}
@ Override
public String toString () {
volver website_name;
}
}
Tenga en cuenta que la clase DummyContent encapsular supone en la actualidad tres elementos en forma de
cadenas que se leía "Punto 1", "Sección 2" y "Sección 3":
public static Map <String, DummyItem> ITEM_MAP = new HashMap <String,

DummyItem> ();
static {
// Añadir 3 elementos de la muestra.
addItem (nuevo DummyItem ("1", "Punto 1"));
addItem (nuevo DummyItem ("2", "Artículo 2"));
addItem (nuevo DummyItem ("3", "Tema 3"));
}
Este código debe ser modificado para inicializar el modelo de datos con los datos del sitio web deseado:
public static Map <String, DummyItem> ITEM_MAP =

new HashMap <String, DummyItem> ();
static {
// Añadir 3 elementos de la muestra.
addItem (nuevo DummyItem ("1", "eBookFrenzy",
"Http://www.ebookfrenzy.com"));
addItem (nuevo DummyItem ("2", "Amazonas",
"Http://www.amazon.com"));
addItem (nuevo DummyItem ("3", "Wikipedia",
"Http://www.wikipedia.org"));
}
Ahora, el código se aprovecha de la clase DummyItem modificado para almacenar un ID, nombre del sitio web y
la URL de cada artículo.
Cambiar el panel de detalles

La información detallada se muestra al usuario cuando se selecciona un elemento de la lista principal está
actualmente representada a través de la disposición contenida en el archivo fragment_website_detail.xml. Por
defecto, este contiene una visión única en la forma de un TextView. Desde la clase TextView no es capaz de
mostrar una página web, este debe ser cambiado a un objeto WebView para los fines de este tutorial. Para
lograr esto, vaya a la MasterDetailFlow -> aplicación -> src -> principal -> res -> diseño -> archivo
fragment_website_detail.xml en la ventana de herramientas del proyecto y haga doble clic en él para cargarlo en
la herramienta Diseñador.Cambiar al modo de diseño antes de hacer clic derecho sobre el fondo blanco de la
tela de la pantalla (lo que representa el TextView) y seleccionando la opción de menú Eliminar en el menú
resultante para eliminar el TextView de la disposición. Localice el componente WebView de la sección Widgets
de la paleta de herramientas Diseñador y arrastrar y soltar en el lienzo de diseño. Con la instancia WebView
recién agregado seleccionado en la disposición de diseño, utilice el panel Propiedades o los botones de la barra
de herramientas Diseñador cambiar tanto el diseño: la altura y el diseño: propiedades de ancho a match_parent
para que la vista se llena el espacio disponible, como se ilustra en la Figura 26- 5:
Figura 26-5
Haga doble clic en la instancia WebView en el diseño y, en el panel resultante, cambie el ID del componente que
@ + / Identificación del website_detail.
Modificación de la Clase WebsiteDetailFragment

En este punto, el panel de detalle interfaz de usuario ha sido modificado pero la clase Java correspondiente
todavía está diseñada para trabajar con un objeto TextView en lugar de un WebView. Cargue el código fuente
de esta clase haciendo doble clic en el archivo WebsiteDetailFragment.java en la ventana de herramientas del
proyecto.Dentro del archivo de origen localizar el método onCreateView (), que queda redactado como se indica
en el siguiente listado:
com.ebookfrenzy.masterdetailflow paquete;
com.example.masterdetailflow.dummy.DummyContent importación;
public class WebsiteDetailFragment extiende Fragmento {

.
.
@ Override
Ver onCreateView público (inflater LayoutInflater, contenedor ViewGroup,
Ver rootView =
inflater.inflate (R.layout.fragment_website_detail,
contenedor, false);
// Mostrar el contenido de prueba en forma de texto en una TextView.

si (mItem! = null) {
((TextView) rootView.findViewById (R.id.website_detail))
.setText (mItem.content);
}
volver rootView;
}
Con el fin de cargar la página web URL correspondiente al elemento seleccionado en la actualidad sólo una
línea de código que hay que cambiar. Una vez que se ha realizado este cambio, el método debe ser el siguiente
(nota también la incorporación de la directiva de importación para la biblioteca android.webkit.WebView):
com.ebookfrenzy.masterdetailflow paquete;
android.webkit.WebView importación;
com.example.masterdetailflow.masterdetailflow.dummy.DummyContent importación;
public class WebsiteDetailFragment extiende Fragmento {

.
.
.
@ Override
pública Vista onCreateView (inflater LayoutInflater, ViewGroup
contenedor, Bulto savedInstanceState) {
Ver rootView =
inflater.inflate (R.layout.fragment_website_detail,
contenedor, false);
// Mostrar el contenido de prueba en forma de texto en una TextView.

si (mItem! = null) {
((WebView) rootView.findViewById (R.id.website_detail))
.loadUrl (mItem.website_url);
}
volver rootView;
}
}
Todo lo que este cambio hace es encontrar la visión con el ID de website_detail (esto fue formalmente la
TextView pero ahora es un WebView), extrae la dirección URL del sitio web desde el elemento seleccionado y
encarga al objeto WebView para cargar la página.
Adición de permisos Manifest

El último paso es agregar el permiso de Internet a la aplicación a través del archivo de manifiesto. Esto permitirá
que el objeto WebView para acceder a Internet y descargar páginas web. Busque y cargar el archivo
AndroidManifest.xml en la ventana de herramientas del proyecto y haga doble clic en él para cargarlo en el
editor. Una vez cargado, añada la línea correspondiente permiso al archivo:

paquete = "com.example.masterdetailflow.masterdetailflow">
<Usa-permiso android: name = "android.permission.INTERNET" />
<Application
android: theme = "@ style / AppTheme">.
.
.
</ Manifiesto>
Compila y ejecuta la aplicación en un emulador configurado adecuadamente o un dispositivo Android
conectado. Dependiendo del tamaño de la pantalla, la aplicación aparecerá ya sea en pequeña pantalla o el
modo de dos paneles. En cualquier caso, la lista maestra debe aparecer cebado con los nombres de los tres
sitios web definidos en el modelo de contenido. Al seleccionar un elemento debe hacer que el sitio web
correspondiente aparezca en el panel de detalles, como se ilustra en el modo de dos paneles en la Figura 26-6:
Figura 26-6
Resumen
Una interfaz de usuario maestro / detalle consiste en una lista maestra de artículos que, cuando se selecciona,
muestran información adicional acerca de que la selección dentro de un panel de detalles. El maestro / detalle
Flow es una plantilla proporcionada con Android Studio que permite una disposición maestro / detalle que se
creará de forma rápida y con relativa facilidad. Como se ha demostrado en este capítulo, con modificaciones
menores a los archivos de plantilla por defecto, una amplia gama de maestro / detalle funcionalidad basada
puede ser implementado con la codificación mínima y esfuerzo de diseño.
26 Creación y administración de desbordamiento de los
menús en Android Estudio
Un espacio de diseño de la interfaz de usuario que aún no ha sido cubierto en este libro se relaciona con el
concepto de menús dentro de una aplicación Android. Menús proporcionan un mecanismo para ofrecer opciones
adicionales para el usuario más allá de los componentes de vista que están presentes en el diseño de interfaz
de usuario.Aunque hay un número de diferentes sistemas de menú disponibles para el desarrollador de
aplicaciones Android, este capítulo se centrará en el menú Desbordamiento más comúnmente utilizado.
menú de desbordamiento
El menú de desbordamiento (también referido como el menú de opciones) es un menú que es accesible para el
usuario desde la pantalla del dispositivo y permite al desarrollador para incluir otras opciones de aplicación más
allá de los incluidos en la interfaz de usuario de la aplicación. La ubicación del menú de desbordamiento
depende de la versión de Android que se ejecuta en el dispositivo. En un dispositivo con Android 2.3.3, por
ejemplo, el menú de desbordamiento está representada por el icono del menú situado en el centro (entre los
botones de la espalda y de búsqueda) de la barra de herramientas tecla inferior como se ilustra en la Figura 27-
1:
Figura 27-1
Con el lanzamiento de Android 4.0 y posteriores, por el contrario, el menú de desbordamiento se encuentra en la
esquina superior derecha (Figura 27-2) en la barra de herramientas de la acción representada por la pila de tres
plazas:
Figura 27-2
Creación de un menú de desbordamiento

Los elementos de un menú se pueden declarar dentro de un archivo XML, que luego se infla y se muestra al
usuario en la demanda. Esto implica el uso del elemento <Menu>, que contiene un <item> sub-elemento para
cada elemento del menú. La siguiente XML, por ejemplo, define un menú que consta de dos elementos de menú
relacionados con opciones de color:
<Xmlns menú: androide = "http://schemas.android.com/apk/res/android"

xmlns: app = "http://schemas.android.com/apk/res-auto"
"Com.demo.menuexample.menuexample.MenuExampleActivity">
<Item
android: id = "@ + / Identificación del menu_red"
android: orderInCategory = "1"
android: showAsAction = "nunca"
android: title = "@ string / red_string" />
<Item
android: id = "@ + / Identificación del menu_green"
android: title = "@ string / green_string" />
</ Menú>
En el XML anterior, el androide: propiedad orderInCategory dicta el orden en el que aparecerán los elementos
del menú en el menú cuando se muestra. El androide: propiedad showAsAction, por otro lado, controla las
condiciones en las que el elemento correspondiente aparece como un elemento dentro de la propia barra de
acción. Si se establece en ifRoom, por ejemplo, el artículo aparecerá en la barra de acción si no hay suficiente
espacio. La figura 27-3 muestra el efecto de establecer esta propiedad en ifRoom para ambos elementos del
menú:
Figura 27-3
Esta propiedad se debe utilizar con moderación para evitar el exceso de abarrotar la barra de acción.
De forma predeterminada, un archivo XML menú es creado por Android Studio cuando se crea un nuevo
proyecto de aplicación para Android. Este archivo se encuentra en el src -> principal -> res -> carpeta del
proyecto de menús y contiene un elemento de menú único titulado "Ajustes":
xmlns menú: androide = "http://schemas.android.com/apk/res/android"

"Com.ebookfrenzy.menuapp.menuapp.FragmentExampleActivity">
<Item android: id = "@ + id / action_settings"
android: title = "@ string / action_settings"
aplicación: showAsAction = "nunca" />
</ Menú>
Este menú ya está configurado para que aparezca cuando el usuario selecciona el menú de desbordamiento en
la interfaz de usuario cuando la aplicación se está ejecutando, por lo que simplemente modificar éste para
satisfacer sus necesidades.
Viendo un menú de desbordamiento

Un menú de desbordamiento se crea reemplazando el método onCreateOptionsMenu () de la actividad
correspondiente y luego inflar archivo XML del menú. Por ejemplo, el código siguiente crea el menú de
contenido dentro de un activity_menu_app archivo de menú XML denominado:
@ Override
. getMenuInflater () inflar (R.menu.activity_menu_app, menú);
return true;
}
Al igual que con el archivo de menú XML, Android Estudio ya se habrá anulado este método en la actividad
principal de un proyecto de aplicación de Android que acaba de crear.En el caso de que un menú de
desbordamiento no se requiere en su actividad, ya sea quitar o comente este método.
Respondiendo a Menú Elemento Selecciones

Una vez que el menú se ha implementado, la pregunta que surge es cómo la aplicación recibe una notificación
cuando el usuario realiza selecciones de elementos de menú.Todo lo que una actividad tiene que hacer para
recibir notificaciones de selección de menú es reemplazar el método onOptionsItemSelected (). Pasa como
argumento de este método es una referencia al elemento de menú seleccionado. El método GetItemID () puede
entonces ser llamado en el elemento para obtener el ID que pueden, a su vez, se utiliza para identificar qué
elemento fue seleccionado. Por ejemplo:
@ Override
interruptor (item.getItemId ()) {
caso R.id.menu_red:
// Elemento Roja fue seleccionada
return true;
caso R.id.menu_green:
// Elemento verde fue seleccionado
return true;
por defecto:
}
}
Creación de grupos de artículos checkable

Además de configurar los elementos de menú independientes, también es posible crear grupos de elementos de
menú. Esto es de uso particular cuando se crea elementos de menú checkable mediante el cual sólo uno de una
serie de opciones se pueden seleccionar en cualquier momento. Los elementos de menú se pueden asignar a
un grupo envolviéndolos en el <grupo> etiqueta. El grupo se declara como comprobable mediante el androide:
propiedad checkableBehavior, estableciendo el valor en tanto simple, todos o ninguno. El siguiente código XML
declara que dos elementos de menú constituyen un grupo en el que sólo un elemento puede ser seleccionado
en un momento dado:
<Xmlns menú: androide = "http://schemas.android.com/apk/res/android">

<Androide grupo: checkableBehavior = "single">
<Item
<Item
</ Group>
</ Menú>
Cuando un grupo de menú está configurado para ser comprobable, un pequeño círculo aparece junto al
elemento en el menú, como se ilustra en la Figura 27-4. Es importante tener en cuenta que la conexión y la
desconexión de este indicador no se realiza de forma automática. Es, por lo tanto, la responsabilidad de la
aplicación para comprobar y desmarque la opción de menú.
Figura 27-4
Siguiendo con el ejemplo del color utilizado anteriormente en este capítulo, esto se llevaría a cabo de la
siguiente manera:
@ Override
caso R.id.menu_red:
si (item.isChecked ()) item.setChecked (false);
otra cosa item.setChecked (true);
mainLayout.setBackgroundColor (android.graphics.Color.RED);
return true;
mainLayout.setBackgroundColor (android.graphics.Color.GREEN);
return true;
por defecto:
}
}
Para ver el menú de desbordamiento en la acción, crear un nuevo proyecto en Android de estudio, entrar
MenuExample en el campo Nombre de la aplicación y ebookfrenzy.com como el ajuste de dominio de la
empresa antes de hacer clic en el botón Siguiente.
actividad en blanco denominada MenuExampleActivity con una disposición correspondiente llamado
activity_menu_example.
Cuando se ha creado el proyecto, vaya a la MenuExample -> aplicación -> src -> principal -> res -> carpeta de
diseño en la ventana de herramientas de proyecto y haga doble clic en el archivo activity_menu_example.xml
para cargar en la herramienta Android Studio Designer . Encienda la herramienta al modo, haga doble clic en el
fondo de la disposición (el área que representa la vista RelativeLayout) Diseñar e introducir layoutView en el
campo id de la emergente del panel.
Modificación del menú Descripción

Dentro de la ventana de la herramienta de proyectos, busque la aplicación del proyecto -> src -> principal -> res
-> Menú -> archivo menu_example.xml y haga doble clic en él para cargarlo en el panel de edición. Eliminar el
elemento de menú Ajustes predeterminados añadido por Android Studio y luego añadir nuevos elementos como
grupo comprobable para que el archivo XML se estructura de la siguiente manera:
<Xmlns menú: androide = "http://schemas.android.com/apk/res/android"

herramientas: context = ". MenuExampleActivity">
<Androide grupo: checkableBehavior = "single">

<Item
<Item
<Item
android: id = "@ + / Identificación del menu_yellow"
android: title = "@ string / yellow_string" />
<Item
android: id = "@ + / Identificación del menu_blue"
android: title = "@ string / blue_string" />
</ Group>
</ Menú>
Busque y haga doble clic en la aplicación -> src -> principal -> res -> Valores -> archivo strings.xml. Dentro del
archivo, añadir nuevos recursos de cadena para los nombres de color según se menciona por los elementos del
menú:

<recursos>
<String name = "nombre_apl"> MenuExample </ string>
<String name = "hello_world"> ¡Hola, mundo! </ String>
<String name = "menu_settings"> Configuración </ string>
<String name = "red_string"> Rojo </ string>
<String name = "green_string"> Verde </ string>
<String name = "yellow_string"> amarillo </ string>
<String name = "blue_string"> Blue </ string>
</ Recursos>
Modificación de la (Método onOptionsItemSelected)

Cuando los elementos se seleccionan del menú, se llama el método reemplazado onOptionsItemsSelected () de
la actividad de la aplicación. El papel de este método será identificar qué elemento fue seleccionado y cambiar
el color de fondo de la vista de diseño con el color correspondiente. Localice y haga doble clic en el src ->
principal -> Java -> <nombre del paquete> -> MenuExampleActivity.java archivo y modificarlo para reemplazar el
método de la siguiente manera:
com.ebookfrenzy.menuexample paquete;
public class MenuExampleActivity extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_menu_example);
}
@ Override
presente.
. getMenuInflater () inflar (R.menu.menu_example, menú);
return true;
}
@ Override
RelativeLayout mainLayout =
(RelativeLayout) findViewById (R.id.layoutView);

caso R.id.menu_red:
mainLayout.setBackgroundColor (android.graphics.Color.RED);
return true;
mainLayout.setBackgroundColor (android.graphics.Color.GREEN);
return true;
caso R.id.menu_yellow:
mainLayout.setBackgroundColor (android.graphics.Color.YELLOW);
return true;
caso R.id.menu_blue:
mainLayout.setBackgroundColor (android.graphics.Color.BLUE);
return true;
por defecto:
}
}
.
.
}
Genere y ejecute la aplicación a ambos un emulador o dispositivo Android física. Uso del menú de
desbordamiento, elementos de menú seleccionar y verificar que el fondo trazado cambios de color
adecuada. Tenga en cuenta que el color seleccionado actualmente se muestra como el elemento activado en el
menú.
Figura 27-5
Resumen
En las versiones anteriores de Android, el menú de desbordamiento es accesible desde la barra de
herramientas tecla de función en la parte inferior de la pantalla. En Android 4.0 y versiones posteriores, se
accede al menú de la extrema derecha de las acciones barra de herramientas en la parte superior de la
pantalla. Este menú ofrece una ubicación para aplicaciones para proporcionar opciones adicionales para el
usuario.
La estructura del menú se define más fácilmente dentro de un archivo XML y la actividad de la aplicación recibe
notificaciones de las selecciones de elementos de menú por razones imperiosas e implementar el método
onOptionsItemSelected ().
27 Animación de interfaces de usuario en Android Studio
usando el Marco Transiciones
El marco Transiciones Android fue introducido como parte de la versión Android 4.4 KitKat y está diseñada para
hacer más fácil para usted, como un desarrollador de Android, añadir efectos de animación a las opiniones que
conforman las pantallas de las aplicaciones. Como se indica en ambos éste y los siguientes capítulos, efectos
animados tales como hacer las visitas en una interfaz de usuario se desvanecen suavemente dentro y fuera de
la vista y se deslizan suavemente a nuevas posiciones en la pantalla se puede implementar con sólo unos
simples líneas de código cuando utilizando el marco de transiciones en Android Studio.
Introducción de las transiciones y escenas Android

Las transiciones permiten que los cambios realizados en el diseño y el aspecto de los puntos de vista en una
interfaz de usuario para ser animados en tiempo de ejecución de la aplicación. Aunque hay un número de
diferentes formas de implementar las transiciones desde dentro de código de la aplicación, tal vez el más
potente mecanismo implica el uso de escenas. Una escena representa o bien todo el diseño de una pantalla de
interfaz de usuario, o un subconjunto de la disposición (representado por una ViewGroup).
Para implementar transiciones que utilizan este enfoque, las escenas están definidos que reflejan los dos
estados de interfaz de usuario diferentes (que pueden ser considerados como el "antes" y "después" de
escenas). Una escena, por ejemplo, puede consistir en una edición de textos, Button y TextView posicionado
cerca de la parte superior de la pantalla. La segunda escena podría quitar la vista del botón y mover los objetos
restantes TextEdit y TextView a la parte inferior de la pantalla para hacer espacio para la introducción de una
instancia MapView. Utilizando el marco de la transición, los cambios entre estas dos escenas pueden ser
animados para que el botón desaparece de la vista, la diapositiva TextEdit y TextView a las nuevas ubicaciones
y el mapa se desvanece suavemente a la vista.
Las escenas se pueden crear en código de ViewGroups, o implementadas en los archivos de recursos de
diseño que se cargan en los casos de escena en tiempo de ejecución de la aplicación.
Las transiciones también se puede implementar dinámicamente desde dentro del código de la aplicación. Con
este enfoque, las escenas se crean haciendo referencia a las colecciones de vistas de interfaz de usuario en
forma de ViewGroups con transiciones luego ser llevadas a cabo en aquellos elementos que utilizan la clase
TransitionManager, que ofrece una amplia gama de métodos para promover y gestionar las transiciones entre
escenas.
Tal vez la forma más simple de transición implica el uso del método beginDelayedTransition () de la clase
TransitionManager. Cuando se llama y aprobado el ViewGroup que representa una escena, cualquier cambio
posterior de los puntos de vista dentro de la escena (como mover, redimensionar, añadir o suprimir
visualizaciones) estarán animados por el marco de la transición.
La animación real es manejado por el marco de transición a través de las instancias de la clase de
transición. Casos de transición son responsables de detectar cambios en el tamaño, la posición y la visibilidad
de los puntos de vista dentro de una escena y animación de esos cambios en consecuencia.
Por defecto, las transiciones serán animados utilizando un conjunto de criterios definidos por la clase
AutoTransition. Transiciones personalizadas pueden ser creadas a través de ajustes en archivos XML de
transición o directamente en el código. Múltiples transiciones pueden combinarse entre sí en una TransitionSet y
configurado para llevar a cabo ya sea en paralelo o secuencialmente.
Usando Interpoladores con transiciones

El marco Transiciones hace un uso extensivo del marco Animación Android para aplicar efectos de
animación. Este hecho es en gran parte incidental al utilizar transiciones ya que la mayoría de esta obra sucede
detrás de las escenas, de modo que protege el desarrollador de algunas de las complejidades del marco de
Animación. Un área donde algún conocimiento del marco de Animación es beneficiosa cuando se utiliza
Transiciones, sin embargo, implica el concepto de interpoladores.
Interpoladores son una característica del marco Android Animación que permite animaciones para ser
modificados en un número de formas predefinidas. En la actualidad el marco de Animación proporciona las
siguientes interpoladores, todos los cuales están disponibles para su uso en la personalización de transiciones:
 AccelerateDecelerateInterpolator - Por defecto, la animación se realiza a una velocidad constante. El

AccelerateDecelerateInterpolator se puede utilizar para causar la animación para comenzar lentamente y
luego acelerar en el medio antes de perder velocidad hacia el final de la secuencia.
 AccelerateInterpolator - Como su nombre lo indica, el AccelerateInterpolator comienza la animación
lentamente y se acelera a una velocidad especificada sin desaceleración al final.
 AnticipateInterpolator - El AnticipateInterpolator proporciona un efecto similar al de una honda. La
vista se mueve animados en la dirección opuesta a la animación configurada por una corta distancia antes
de ser arrojado hacia adelante en la dirección correcta. La cantidad de fuerza hacia atrás puede ser
controlado a través de la especificación de un valor de tensión.
 AnticipateOvershootInterpolator - combina el efecto proporcionado por el AnticipateInterpolator con
el objeto animado rebasamiento y luego regresar a la posición de destino en la pantalla.
 BounceInterpolator - Provoca la vista animado a rebotar en destino en su posición de destino.
 CycleInterpolator - Configura la animación se repita un número determinado de veces.
 DecelerateInterpolator - El DecelerateInterpolator hace que la animación para comenzar rápidamente
y luego desacelerarse por un factor especificado ya que se acerca el final.
 LinearInterpolator - Se utiliza para especificar que la animación es que se realiza a un ritmo
constante.
 OvershootInterpolator - Provoca la vista animado a rebasar la posición de destino especificado antes
de regresar. El exceso se puede configurar mediante la especificación de un valor de tensión.
Como se demostrará en este y posteriores capítulos, interpoladores pueden especificarse tanto en los archivos
de código y XML.
Trabajo con transiciones de escena

Las escenas pueden ser representados por el contenido de un archivo de diseño de Android Estudio XML. La
siguiente XML, por ejemplo, podría ser usado para representar una escena que consiste en tres vistas de botón
dentro de un padre RelativeLayout:

android: id = "@ + / Identificación del RelativeLayout1"
<Botón
android: onClick = "goToScene2"
android: text = "@ string / one_string" />
<Botón
android: layout_alignParentRight = "true"
android: text = "@ string / two_string" />
<Botón
android: text = "@ string / three_string" />
</ RelativeLayout>
Suponiendo que el diseño anterior reside en un archivo llamado scene1_layout.xml ubicado en la carpeta res /
layout del proyecto, el diseño se puede cargar en una escena utilizando el método getSceneForLayout () de la
clase de escena. Por ejemplo:
Escena scene1 = Scene.getSceneForLayout (rootContainer,

R.layout.scene1_layout, este);
Tenga en cuenta que la llamada al método requiere una referencia al contenedor raíz. Esta es la vista en la
parte superior de la jerarquía de la vista en la que la escena se va a mostrar.
Para mostrar una escena para el usuario sin ninguna animación de transición, la tecla ENTER () método se
llama en la instancia de escena:
scene1.enter ();
Las transiciones entre dos escenas usando la clase AutoTransition defecto se pueden activar utilizando el
método go () de la clase TransitionManager:
TransitionManager.go (scene2);
Casos de escena se pueden crear fácilmente en código agrupando los elementos de la vista en uno o más
ViewGroups y luego la creación de una escena de esos grupos. Por ejemplo:
Escena scene1 = Escena (viewGroup1);

Escena scene2 = Escena (viewGroup2, viewGroup3);
Transiciones y TransitionSets en código personalizado

Los ejemplos descritos hasta ahora en este capítulo han utilizado los ajustes de transición predeterminada en la
que el cambio de tamaño, la decoloración y el movimiento están animadas utilizando el comportamiento pre-
configurado. Estos pueden ser modificados mediante la creación de transiciones personalizadas que luego se
hace referencia durante el proceso de transición. Las animaciones se clasifican ya sea como primer cambio (en
relación a los cambios en la posición y el tamaño de una vista) y se desvanecen (relativa a la visibilidad o no de
una vista).
Una sola transición puede ser creado como sigue:
MyChangeBounds Transición = new ChangeBounds ();
Esta nueva transición a continuación, se puede utilizar cuando se realiza una transición:
TransitionManager.go (Escena2, myChangeBounds);
Múltiples transiciones pueden ser agrupados juntos en una instancia TransitionSet. El siguiente código, por
ejemplo, crea un nuevo objeto TransitionSet consistente en ambos límites de cambio y efectos de transición de
fundido:
TransitionSet myTransition = new TransitionSet ();

myTransition.addTransition (nuevos ChangeBounds ());
myTransition.addTransition (nuevo Fundido ());
Las transiciones pueden ser configurados para apuntar vistas específicas (referenciados por una vista de
ID). Por ejemplo, el código siguiente configurará la transición de fundido anterior sólo estén dirigidos a la vista
con un ID que coincide myButton1:
TransitionSet myTransition = new TransitionSet ();

myTransition.addTransition (nuevos ChangeBounds ());
Fade Transición = new Fundido ();
fade.addTarget (R.id.myButton1);
myTransition.addTransition (fade);
Aspectos adicionales de la transición también pueden ser personalizados, tales como la duración de la
animación. El código siguiente especifica la duración sobre los que la animación se va a realizar:
Transición changeBounds = new ChangeBounds ();

changeBounds.setDuration (2000);
Como con los casos de transición, una vez que se ha creado una instancia de TransitionSet, que puede ser
utilizado en una transición a través de la clase TransitionManager. Por ejemplo:
TransitionManager.go (scene1, myTransition);
Transiciones y TransitionSets en XML personalizados

Mientras transiciones personalizadas se pueden implementar en el código, a menudo es más fácil hacerlo a
través de archivos de transición XML utilizando los <fade> y <changeBounds> etiquetas junto con algunas
opciones adicionales. El siguiente código XML incluye una sola transición changeBounds:

<ChangeBounds />
Al igual que con el enfoque basado en código para trabajar con transiciones, cada entrada de transición en un
archivo de recursos puede ser personalizado. El XML a continuación, por ejemplo, configura una duración para
una transición de cambio de límites:
<ChangeBounds android: duración = "5000">
Múltiples transiciones pueden ser agrupados juntos usando el elemento <transitionSet>:

<TransitionSet
<Fade
android: duración = "2000"
android: fadingMode = "fade_out" />
<changeBounds
android: duración = "5000">
<objetivos>
<Androide objetivo: targetId = "@ id / button2" />
</ objetivos>
</ ChangeBounds>
<Fade
android: fadingMode = "fade_in" />
</ TransitionSet>
Transiciones contenidas dentro de un archivo de recursos XML deben guardarse en la carpeta res / transición
del proyecto en el que están siendo utilizados y deben ser inflados antes de ser referencia en el código de una
aplicación. El siguiente código, por ejemplo, infla los recursos de transición contenidos en un archivo llamado
transition.xml y asigna los resultados a una referencia con nombre myTransition:
Transición myTransition = TransitionInflater.from (esto)

.inflateTransition (R.transition.transition);
Una vez inflado, la nueva transición se puede hacer referencia en la forma habitual:
TransitionManager.go (scene1, myTransition);

De forma predeterminada, los efectos de transición dentro de un TransitionSet se realizan en
paralelo. Encomendar al marco de transición para realizar la secuencialmente animaciones, añadir el androide
apropiado: transitionOrdering alojamiento hasta el elemento transitionSet del archivo de recursos:
<TransitionSet
android: transitionOrdering = "secuencial">
<Fade
android: fadingMode = "fade_out" />
<changeBounds
</ ChangeBounds>
</ TransitionSet>
Cambie el valor de "secuencial" para "juntos" para indicar que las secuencias de animación se han de realizar
en paralelo.
Trabajar con Interpoladores

Como se discutió previamente, interpoladores se pueden utilizar para modificar el comportamiento de una
transición en una variedad de formas y pueden ser fijados, bien en código o a través de la configuración dentro
de un archivo de recursos XML transición.
Cuando se trabaja en el código, nuevas instancias del interpolador se pueden crear mediante una llamada al
método constructor de la clase interpolador requerida y, en su caso, pasando a través de valores para modificar
adicionalmente el comportamiento del interpolador:
 AccelerateDecelerateInterpolator ()
 AccelerateInterpolator (factor de flotación)
 AnticipateInterpolator (tensión de flotación)
 AnticipateOvershootInterpolator (tensión de flotación)
 BounceInterpolator ()
 CycleInterpolator (ciclos float)
 DecelerateInterpolator (factor de flotación)
 LinearInterpolator ()
 OvershootInterpolator (tensión de flotación)
Una vez creado, una instancia interpolador se puede conectar a una transición utilizando el método
setInterpolator () de la clase de transición. El siguiente código, por ejemplo, agrega un interpolador rebote para
una transición de cambio de límites:

changeBounds.setInterpolator (nuevo BounceInterpolator ());
Del mismo modo, el código siguiente añade un interpolador acelerar a la misma transición, especificando un
factor de aceleración de 1,2:
changeBounds.setInterpolator (nuevo AccelerateInterpolator (1.2f));
En el caso de los recursos de transición basados en XML, un interpolador predeterminada se declara con la
siguiente sintaxis:
android: interpolador = "@ android: anim / <interpolator_element>"
En la sintaxis anterior, <interpolator_element> debe ser reemplazado por el ID de recurso del interpolador
correspondiente seleccionado de la lista siguiente:
 accelerate_decelerate_interpolator
 accelerate_interpolator
 anticipate_interpolator
 anticipate_overshoot_interpolator
 bounce_interpolator
 cycle_interpolator
 decelerate_interpolator
 linear_interpolator
 overshoot_interpolator
El siguiente fragmento XML, por ejemplo, agrega un interpolador de rebote a una transición de cambio de límites
contenida dentro de un conjunto de transición:

<TransitionSet
<changeBounds
android: interpolador = "@ android: anim / bounce_interpolator"
android: duración = "2000" />
<Fade
android: fadingMode = "fade_in" />
</ TransitionSet>
Este enfoque de la adición de interpoladores a las transiciones dentro de los recursos XML funciona bien
cuando se requiere que el comportamiento predeterminado del interpolador. La tarea se vuelve un poco más
compleja cuando el comportamiento predeterminado de un interpolador necesita ser cambiado. Tomemos, por el
bien de un ejemplo, el interpolador ciclo. El propósito de este interpolador es hacer una animación o de
transición repiten un número de veces especificado. En ausencia de un atributo ciclos ajuste, el interpolador
ciclo realizará un solo ciclo. Desafortunadamente, no hay forma de especificar directamente el número de ciclos
(o cualquier otro atributo interpolador para el caso) cuando se añade un interpolador utilizando la técnica
anterior. En cambio, un interpolador personalizado debe ser creado y luego hace referencia en el archivo de
transición.
Creación de un interpolador personalizada

Un interpolador personalizado debe ser declarado en un archivo XML independiente y se almacena en la
carpeta res / anim del proyecto. El nombre del archivo XML se utiliza el sistema Android como el ID de recurso
para el interpolador personalizado.
Dentro del archivo de recursos XML interpolador costumbre, la sintaxis debe decir lo siguiente:

<InterpolatorElement xmlns: android = "http://schemas.android.com/apk/res/android"
atributo android: = "valor" />
En la sintaxis anterior, interpolatorElement debe ser reemplazado con el nombre del elemento del interpolador
requerida seleccionado de la lista siguiente:
 accelerateDecelerateInterpolator
 accelerateInterpolator
 anticipateInterpolator
 anticipateOvershootInterpolator
 bounceInterpolator
 cycleInterpolator
 decelerateInterpolator
 linearInterpolator
 overshootInterpolator
La palabra clave de atributo se sustituye por el atributo de nombre del interpolador cuyo valor se va a cambiar
(por ejemplo, la tensión para cambiar el atributo de la tensión de un interpolador exceso). Por último, el valor
representa el valor que se asignará al atributo especificado. La siguiente XML, por ejemplo, contiene un
interpolador de ciclo personalizado configurado para ciclo de 7 veces:
<Xmlns cycleInterpolator: androide = "http://schemas.android.com/apk/res/android"
android: ciclos = "7" />
Suponiendo que el XML anterior se almacena en un archivo de recursos denominado my_cycle.xml almacenado
en la carpeta / proyecto anim res, el interpolador costumbre podría añadirse a un archivo de recursos de
transición con la siguiente sintaxis XML:
<changeBounds
android: interpolador = "@ anim / my_cycle">
Utilizar el método beginDelayedTransition

Tal vez la forma más simple de animación interfaz de usuario basada transición implica el uso del método
beginDelayedTransition () de la clase TransitionManager. Este método se pasa una referencia a la vista de la
raíz de la ViewGroup que representa la escena para la que se requiere la animación. Los cambios posteriores
en los puntos de vista dentro de esa visión sub entonces serán animados utilizando la configuración por defecto
de transición:
myLayout = (ViewGroup) findViewById (R.id.myLayout);

TransitionManager.beginDelayedTransition (myLayout);
// Realizar cambios en la escena
Si se requiere un comportamiento que no sea el comportamiento de la animación por defecto, simplemente

pasar una transición configurado adecuadamente o instancia TransitionSet a través de la llamada al método:
TransitionManager.beginDelayedTransition (myLayout, myTransition);
Resumen
El Android 4.4 SDK liberación KitKat introdujo el Marco de transición, cuyo objetivo es simplificar la tarea de
añadir animación a los puntos de vista que componen la interfaz de usuario de una aplicación Android. Con un
poco de configuración sencilla y unas pocas líneas de código, efectos de animación tales como el movimiento, la
visibilidad y el cambio de tamaño de puntos de vista pueden ser animados mediante el uso del marco de
transición. Una serie de diferentes enfoques para las transiciones de aplicación están disponibles implica una
combinación de código y los archivos de recursos XML Java. Los efectos de animación de transiciones también
se pueden mejorar mediante el uso de una gama de interpoladores.
Después de haber cubierto algunos de la teoría de las transiciones en Android, los dos capítulos siguientes se
ponga en práctica esta teoría trabajando a través de algunas implementaciones de transición basados ejemplo
Android Studio.
28 Un Android Estudio Transición Tutorial usando

beginDelayedTransition
En el capítulo anterior, titulado Interfaces Animación de usuario en Android estudio utilizando el Marco de

Transitions , hizo una introducción a la animación de interfaces de usuario utilizando el marco Transiciones
Android. En este capítulo se utiliza un enfoque basado en el tutorial para demostrar transiciones Android en
acción utilizando el método beginDelayedTransition () de la clase TransitionManager.
El siguiente capítulo creará un ejemplo más complejo que utiliza archivos de diseño y archivos de recursos de
transición para animar la transición de una escena a otra dentro de una aplicación.
ear el proyecto Android Estudio TransitionDemo
Crear un nuevo proyecto en Android de estudio, entrar TransistionDemo en el campo Nombre de la aplicación y
En la pantalla de factores de forma, activar la opción de teléfono y la tableta y activar el ajuste de 19 API SDK
mínimo: Android 4.4 (KitKat). Continuar para avanzar a través de las pantallas, solicitando la creación de una
actividad en blanco denominada TransitionDemoActivity con una disposición correspondiente llamado
activity_transition_demo.
Preparación de los archivos de proyecto

El primer ejemplo de animación de transición se llevará a cabo mediante el uso del método
beginDelayedTransition () de la clase TransitionManager. El primer paso, sin embargo, es asignar una
identificación a la vista de los elementos de diseño de los padres en el diseño de la interfaz de usuario creada
para nosotros por Android Studio. Si Android Estudio no se carga automáticamente el archivo, busque y haga
doble clic en el TransitionDemo -> aplicación -> src -> principal -> res -> diseño - archivo>
activity_transition_demo.xml en el panel de la ventana de herramientas Proyecto para cargarlo en el Diseñador
herramienta. Una vez cargado, cambie al modo y doble clic en Diseño en el fondo del lienzo vista que
representa el contenedor RelativeLayout padres y, en el panel resultante, nombre el diseño de vista @ + /
Identificación del myLayout y pulse Enter para confirmar el cambio.
Seleccione el objeto TextView que actualmente muestra el mundo Hola! texto y pulse la tecla Eliminar del
teclado para eliminarlo de la disposición. Arrastre un botón de la sección Widget de la paleta Diseñador y
posicionarlo en la esquina superior izquierda de la disposición de la pantalla del dispositivo. Una vez colocado,
haga doble clic en él y especificar un ID de @ + / Identificación del myButton1.
Ejecución beginDelayedTransition Animación

El objetivo de la fase inicial de este tutorial es para implementar un controlador táctil de modo que cuando los
grifos de usuario en el diseño de vista en el botón Vista mueve a la esquina inferior derecha de la pantalla y
aumenta de tamaño.
Busque el archivo TransitionDemoActivity.java (ubicado en la ventana de herramientas Proyecto en
TransitionDemo -> aplicación -> src -> java principal -> com.ebookfrenzy.transitiondemo) y modificar el método
onCreate () para implementar el controlador de onTouch:
com.ebookfrenzy.transitiondemo paquete;
public class TransitionDemoActivity extiende ActionBarActivity {
ViewGroup myLayout;
@ Override
setContentView (R.layout.activity_transition_demo);
myLayout = (ViewGroup) findViewById (R.id.myLayout);
public boolean onTouch (Ver v,
MotionEvent m) {
handleTouch ();
return true;
}
}
);
}
.
.
.
}
El código anterior simplemente establece un oyente contacto en el recipiente RelativeLayout y lo configura para
llamar a un método llamado handleTouch () cuando se detecta un toque. La siguiente tarea, por lo tanto, es
poner en práctica el método handleTouch () como sigue:
public void handleTouch () {

Ver view = findViewById (R.id.myButton1);
RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams

(RelativeLayout.LayoutParams.WRAP_CONTENT,
params.addRule (RelativeLayout.ALIGN_PARENT_RIGHT,
RelativeLayout.TRUE);
params.addRule (RelativeLayout.ALIGN_PARENT_BOTTOM,
view.setLayoutParams (params);
ViewGroup.LayoutParams lparams = view.getLayoutParams ();
lparams.width = 500;
lparams.height = 350;
view.setLayoutParams (lparams);
}
Este método obtiene una referencia a la opinión de botón en el diseño de la interfaz de usuario y crea un nuevo
conjunto de reglas de parámetros de diseño diseñados para mover el botón de la esquina inferior derecha de la
disposición de los padres y para aumentar las dimensiones del botón. Una vez creados, estos nuevos
parámetros se aplican al botón.
Pruebe el código hasta el momento por compilar y ejecutar la aplicación. Una vez puesto en marcha, toque el
fondo (no el botón) y observe que el botón se mueve y cambia el tamaño, como se ilustra en la Figura 29-1:
Figura 29-1
Aunque los cambios en la disposición entró en vigor, lo hicieron de forma instantánea y sin ningún tipo de
animación. Aquí es donde la llamada al método beginDelayedTransition () de la clase TransitionManager entra.
Todo lo que se necesita para agregar animación a este cambio de diseño es la adición de una sola línea de
código antes de implementar los cambios de diseño. Permanecer dentro del archivo
TransitionDemoActivity.java, modifique el código de la siguiente manera:
android.transition.TransitionManager importación;

.
.
.
RelativeLayout.LayoutParams params = new

RelativeLayout.LayoutParams (RelativeLayout.LayoutParams.WRAP_CONTENT,
params.width = 500;
params.height = 350;
}
.
.
.
}
Compile y ejecute la aplicación una vez más y tenga en cuenta que la transición es ahora animado.
Personalización de la Transición
La tarea final en este ejemplo es modificar la transición changeBounds de modo que se realiza sobre una
duración más larga e incorpora un efecto de rebote cuando la vista alcanza su nueva ubicación de la
pantalla. Esto implica la creación de una instancia de Transición con la configuración del interpolador de
duración apropiada, que es, a su vez, pasa a través de un argumento al método beginDelayedTransition ():
android.transition.ChangeBounds de importación;
android.transition.Transition importación;
android.view.animation.BounceInterpolator importación;

.
.
.

changeBounds.setDuration (3000);
changeBounds.setInterpolator (nuevo BounceInterpolator ());
TransitionManager.beginDelayedTransition (myLayout,
changeBounds);
RelativeLayout.LayoutParams params = new

RelativeLayout.LayoutParams (RelativeLayout.LayoutParams.WRAP_CONTENT,
params.width = 500;
params.height = 350;
}
Cuando ahora se ejecuta la aplicación, la animación será más lento para que coincida con el nuevo ajuste de la
duración y el botón saltará al llegar a la esquina inferior derecha de la pantalla.
Resumen
La forma más básica de la animación de transición implica el uso del método beginDelayedTransition () de la
clase TransitionManager. Una vez llamada, cualquier cambio en el tamaño y la posición de los puntos de vista
en el siguiente fotograma renderizado interfaz de usuario, y dentro de un grupo vista definida, estarán animados
usando las transiciones especificadas. En este capítulo se ha trabajado a través de un ejemplo sencillo Android
estudio que demuestra el uso de este enfoque a las transiciones de ejecución.
29 Ejecución Escena Android Transiciones - Un Estudio
Android Tutorial
En este capítulo se basará en la teoría se describe en el capítulo Interfaces Animación de usuario en Android

Studio usando el Marco Transiciones trabajando a través de la creación de un proyecto diseñado para
demostrar la transición de una escena a otra utilizando el marco de Transición Android.
Una visión general del Proyecto de Transición de Escena

La aplicación creada en este capítulo consistirá en dos escenas, cada uno representado por un archivo de
recursos de diseño XML. Una transición se utilizará entonces para animar los cambios de una escena a otra. La
primera escena constará de tres puntos de vista de los botones. La segunda escena contendrá dos de los
botones de la primera escena posicionado en diferentes ubicaciones en la pantalla. El tercer botón estará
ausente de la segunda escena. Una vez que la transición se ha implementado, el movimiento de los dos
primeros botones se animará con un efecto rebote. El tercer botón se desvanecen suavemente a la vista como
las transiciones de solicitud a la primera escena de la segunda.
Crear el proyecto SceneTransitions Android Estudio

Crear un nuevo proyecto en Android de estudio, entrar SceneTransitions en el campo Nombre de la aplicación y
En la pantalla de factores de forma, activar la opción de teléfono y la tableta y activar el ajuste de 19 API SDK
mínimo: Android 4.4 (KitKat). Continuar para avanzar a través de las pantallas, solicitando la creación de una
actividad en blanco denominada SceneTransitionsActivity con una disposición correspondiente nombre
activity_scene_transitions.
La identificación y preparación del contenedor raíz

Cuando se trabaja con transiciones es importante identificar el contenedor raíz de las escenas. Esto es
esencialmente esquema del contenedor padre en la que las escenas se van a mostrar. Cuando se creó el
proyecto, Android Estudio creado un archivo de recursos de diseño en los SceneTransitions -> aplicación -> src
-> principal -> res -> carpeta de distribución llamada activity_scene_transitions.xml y que contiene un solo
contenedor RelativeLayout y TextView. Cuando se inicia la aplicación, este es el primer diseño que se mostrará
al usuario en la pantalla del dispositivo y para los fines de este ejemplo, el contenedor RelativeLayout dentro de
este diseño actuará como el contenedor raíz de las dos escenas.
Comience por localizar el archivo de recursos de diseño activity_scene_transitions.xml y cargarlo en la
herramienta Android Studio Designer. Cambiar al modo de diseño si es necesario, seleccione la opción "Hello
World!" Objeto TextView y eliminarlo de la disposición con la tecla Suprimir del teclado. Haga doble clic en el
fondo de diseño en blanco y en el panel resultante cambie la propiedad ID del objeto de @ + / Identificación del
rootContainer.
El diseño de la primera escena

La primera escena se va a consistir en una disposición relativa que contiene tres vistas de botón. Cree este
archivo de recursos de diseño haciendo clic derecho sobre los SceneTransitions -> aplicación -> src -> principal
-> res -> entrada de diseño en la ventana de herramientas del proyecto y seleccionando Nuevo -> archivo de
recursos de diseño ... opción de menú. En el cuadro de diálogo resultante, el nombre del archivo y seleccione
scene1_layout RelativeLayout como el elemento raíz antes de hacer clic en Aceptar.
Cuando el archivo de diseño de nueva creación ha cargado en la herramienta Diseñador arrastrar una vista
Botón de la sección Widgets de la paleta al lienzo de diseño y colóquelo en la esquina superior izquierda de la
vista de diseño de modo que las propiedades alignParentLeft y alignParentTop se muestran como se ilustra en
la Figura 30-1. La caída de la vista del botón en esta posición, haga doble clic en él y cambiar la propiedad de
texto a "One". Seleccione el icono de la bombilla, haga clic en el mensaje I18N y extraer la cadena en un
recurso denominado one_string.
Figura 30-1
Arrastre un segundo punto de vista Botón de la paleta y colóquelo en la esquina superior derecha de la vista de
diseño de modo que las propiedades alignParentRight y alignParentTop se muestran antes de bajar la vista en
su lugar. La repetición de los pasos para el primer botón, asignar el texto que dice "Dos" al botón y extraer en un
recurso de cadena denominada y two_string.
Arrastre un tercer punto de vista de Button y colocarlo de manera que quede centrado tanto horizontal como
verticalmente dentro del diseño, esta vez la configuración de una llamada three_string recurso de cadena que
dice "Tres". Al completar los pasos anteriores, el diseño de la primera escena debe ser similar a la que se
muestra en la Figura 30-2:
Figura 30-2
Encienda la herramienta Diseñador de modo de texto para editar directamente los recursos de XML para el
diseño. Verifique que coincida con el XML que se enumeran a continuación antes de añadir las propiedades
OnClick en el primer y segundo botón. Estos métodos se ejecutarán después de activar las transiciones de una
escena a otra:

android: layout_width = "match_parent" android: layout_height = "match_parent">
<Botón
android: text = "@ string / one_string"
android: onClick = "goToScene2" />
<Botón
android: text = "@ string / two_string"
android: layout_alignParentEnd = "true"
android: onClick = "goToScene1" />
<Botón
android: text = "@ string / three_string"
</ RelativeLayout>
El diseño de la segunda escena

La segunda escena es simplemente una versión modificada de la primera escena. El primer y segundo botones
seguirán presentes, pero se encuentra en la parte inferior curvas a derecha e izquierda de la disposición
respectivamente. El tercer botón, por otro lado, ya no estará presente en la segunda escena.
A los efectos de evitar la duplicación de esfuerzos, el archivo de diseño para la segunda escena se crea
copiando y modificando el archivo scene1_layout.xml. Dentro de la ventana de la herramienta de proyectos,
busque la aplicación -> src -> principal -> res -> diseño - archivo> scene1_layout.xml, haga clic derecho sobre él
y seleccione la opción de menú Copiar. Haga clic en la carpeta de presentación, esta vez seleccionando la
opción de menú Pegar y cambiar el nombre del archivo a scene2_layout.xml cuando se le pida hacerlo.
Haga doble clic en el nuevo archivo scene2_layout.xml para cargar en la herramienta Diseñador y cambiar al
modo de diseño si es necesario. Seleccione y elimine el botón "Tres" y mover el primer y segundo botones a la
ubicaciones inferior izquierda esquina inferior derecha y como se ilustra en la Figura 30-3:
Figura 30-3
Interruptor Designer para el modo de texto y compruebe que coincide con el XML que se enumeran a
continuación:

android: layout_width = "match_parent" android: layout_height = "match_parent">
<Botón
android: text = "@ string / one_string"
android: layout_alignParentBottom = "true"
android: layout_alignParentEnd = "true" />
<Botón
android: text = "@ string / two_string"
android: layout_alignParentBottom = "true"
android: layout_alignParentStart = "true" />
</ RelativeLayout>
Entrando en la primera escena

Si la solicitud fuera a correr ahora, se mostraría solamente el diseño en blanco representado por el archivo
activity_scene_transitions.xml. Algunos código debe, por lo tanto, se añade al método onCreate () situado en el
archivo de SceneTransitionsActivity.java de modo que la primera escena se presenta cuando se crea la
actividad. Esto se puede lograr de la siguiente manera:
com.ebookfrenzy.scenetransitions paquete;
android.transition.Scene importación;
public class SceneTransitionsActivity extiende ActionBarActivity {
ViewGroup rootContainer;
Scene1 escena;
@ Override
setContentView (R.layout.activity_scene_transitions);
rootContainer =
(ViewGroup) findViewById (R.id.rootContainer);
scene1 = Scene.getSceneForLayout (rootContainer,

scene1.enter ();
}
.
.
}
El código añadido a la clase de actividad declara algunas variables en el que almacenar referencias al
contenedor raíz y primera escena y obtiene una referencia a la vista contenedor raíz. El método
getSceneForLayout () de la clase de escena se utiliza entonces para crear una escena de la disposición
contenida en el archivo scene1_layout.xml para convertir ese diseño en una escena. La escena se introduce a
continuación a través de la tecla ENTER () llamada al método de manera que se muestra al usuario.
Compilar y ejecutar la aplicación en este punto y verificar que la escena 1 se muestra después de la aplicación
ha puesto en marcha.
Cargando Escena 2
Antes de la aplicación de la transición entre la primera y segunda escena es primero necesario añadir algo de
código para cargar la disposición del archivo scene2_layout.xml en una instancia de escena. Permanecer en el
archivo SceneTransitionsActivity.java, por lo tanto, agregar el código de la siguiente manera:
Scene1 escena;
Scene2 escena;
@ Override
rootContainer =


scene1.enter ();
}
.
.
}
La aplicación de las transiciones

El primer y segundo botones se han configurado para llamar a métodos llamados goToScene2 y goToScene1
respectivamente cuando se selecciona. Como sugieren los nombres de método, es la responsabilidad de estos
métodos para desencadenar las transiciones entre las dos escenas. Añadir estos dos métodos dentro del
archivo SceneTransitionsActivity.java para que se lean como sigue:
public void goToScene2 (Ver vista)

{
}

{
}
Ejecute la aplicación y observe que la selección de los dos primeros botones hace que la disposición para
cambiar entre las dos escenas. Dado que todavía tenemos que configurar ninguna transición, estos cambios de
diseño aún no están animados.
Agregar el archivo de Transición

Todos los efectos de transición para este proyecto se implementará dentro de un archivo de recursos XML
transición individual. Como se indica en el capítulo titulado Interfaces Animación de usuario en Android Studio
usando el Marco Transitions , los archivos de recursos de transición deben ser colocados en los
SceneTransitions -> aplicación -> src -> res -> carpeta de transición del proyecto. Comienza, por lo tanto,
haciendo clic derecho sobre la carpeta res en la ventana de herramientas del proyecto y la selección de la
Nueva -> opción de menú Directorio. En el cuadro de diálogo resultante, nombre de la nueva transición carpeta
y haga clic en el botón Aceptar. Haga clic derecho sobre la carpeta nueva transición, esta vez seleccionando la
Nueva -> Tipo de archivo y el nombre de la nueva transition.xml archivo.
Con el archivo transition.xml recién creado seleccionado y cargado en el panel de edición, agregar el siguiente
contenido XML para agregar un conjunto de transición que permite la animación de transición de cambio de
límites con el establecimiento de un atributo de duración:
<TransitionSet
<changeBounds
</ ChangeBounds>
</ TransitionSet>
Cargando y Manejo del Set Transición

Aunque un archivo de recursos de transición ha sido creado y poblado con una transición de cambio de límites,
esto no tendrá ningún efecto hasta que se añade un poco de código para cargar las transiciones en una
instancia de TransitionManager y hacer referencia a ella en los cambios de escena. Los cambios para lograr
esto son los siguientes:
com.ebookfrenzy.scenetransitions paquete;
android.transition.Scene importación;
android.transition.TransitionInflater importación;
Scene1 escena;
Scene2 escena;
TransitionMgr Transición;
@ Override
rootContainer =
transitionMgr = TransitionInflater.from (este)

.inflateTransition (R.transition.transition);


scene1.enter ();
}

{
TransitionManager.go (scene2, transitionMgr);
}

{
TransitionManager.go (scene1, transitionMgr);
}
.
.
}
Cuando la aplicación está ahora ejecutar los dos botones se deslizarán suavemente a sus nuevas posiciones
durante la transición.
Configuración de transiciones adicionales

Con el archivo de transición integrado en el proyecto, cualquier número de transiciones adicionales se puede
añadir al archivo sin la necesidad de hacer más cambios en el código fuente de Java de la actividad. Tome, por
ejemplo, los siguientes cambios en el archivo transition.xml para añadir un interpolador de rebote a la transición
de cambio de límites, introducen una transición de fundido de entrada dirigido al tercer botón y cambiar las
transiciones de tal manera que se realizan secuencialmente:
<TransitionSet
<Fade
android: fadingMode = "fade_in">
<objetivos>
<Androide objetivo: targetId = "@ id / button3" />
</ objetivos>
</ Fade>
<changeBounds
android: interpolador = "@ android: anim / bounce_interpolator">
</ ChangeBounds>
</ TransitionSet>
Botones uno y dos ahora rebotarán al llegar a los destinos finales y tres botones se desvanecen suavemente a
la vista durante la transición a la escena 1 de la escena 2.
Tómese su tiempo para experimentar con diferentes transiciones y interpoladores al hacer cambios en el archivo
transition.xml y volver a ejecutar la aplicación.
Resumen
Transiciones basadas Escena proporcionan un enfoque flexible para la animación de los cambios de diseño de
interfaz de usuario de una aplicación Android. En este capítulo se ha demostrado los pasos implicados en la
animación de la transición entre las escenas representadas por dos archivos de recursos de diseño. Además, el
ejemplo también se utiliza un archivo de recursos XML transición para configurar los efectos de animación de
transición entre las dos escenas.
30 Una visión general de Intenciones en Android Estudio

En esta etapa del libro, debe quedar claro que las aplicaciones de Android se componen, entre otras cosas, de
una o más actividades. Un área que todavía tiene que ser cubierto en gran detalle, sin embargo, es el
mecanismo por el que una actividad puede desencadenar el lanzamiento de otra actividad. Como se indica
brevemente en el capítulo tituladoLa Anatomía de una aplicación Android Android estudio , esto se logra
principalmente mediante Intenciones.
Antes de trabajar a través de algunos ejemplos de implementaciones basadas Android Studio de intentos en los
siguientes capítulos, el objetivo de este capítulo es proporcionar una visión general de las intenciones en forma
de intenciones explícitas y las intenciones implícitas junto con una introducción a los filtros de intención.
na visión general de Intenciones

Intenciones (android.content.Intent) son el sistema de mensajería por el que una actividad es capaz de lanzar
otra actividad. Una actividad puede, por ejemplo, emitir una intención de solicitar la apertura de otra actividad
contenida dentro de la misma aplicación. Intenciones también, sin embargo, van más allá de este concepto al
permitir una actividad para solicitar los servicios de cualquier otra actividad adecuadamente registrado en el
dispositivo para el que se configuran los permisos. Consideremos, por ejemplo, una actividad contenida dentro
de una aplicación que requiere una página web que se carga y se muestra al usuario. En lugar de la aplicación
tenga que contener una segunda actividad para llevar a cabo esta tarea, el código simplemente puede enviar
una intención al tiempo de ejecución Android solicitando los servicios de cualquier actividad que se ha registrado
la posibilidad de mostrar una página web. El sistema de ejecución coincidirá con la solicitud de las actividades
disponibles en el dispositivo y, o bien poner en marcha la actividad que corresponda o, en el caso de varias
coincidencias, permitir al usuario decidir qué actividad va a utilizar.
Intentos también permiten la transferencia de datos desde el envío de la actividad a la actividad receptora. En el
escenario anteriormente descrito, por ejemplo, la actividad enviando tendría que enviar la dirección URL de la
página web que se mostrará a la segunda actividad. Del mismo modo, la actividad de recepción también puede
ser configurado para devolver datos de resultados de la actividad de envío cuando las tareas necesarias se han
completado.
Aunque no cubierta hasta los últimos capítulos, también es de destacar el hecho de que, además de poner en
marcha las actividades, las intenciones también se utilizan para poner en marcha y comunicarse con los
servicios y receptores de radiodifusión.
Intenciones se clasifican como sea explícita o implícita.
Intenciones explícitos
Una intención explícita solicita la puesta en marcha de una actividad específica haciendo referencia al nombre
del componente (que es en realidad el nombre de la clase Java) de la actividad de destino. Este enfoque es más
común en el lanzamiento de una actividad que reside en la misma aplicación que la actividad de envío (desde el
nombre de clase Java se sabe que el desarrollador de aplicaciones).
Una intención explícita es emitida por la creación de una nueva instancia de la clase Intención, pasando por el
contexto de actividad y el nombre del componente de la actividad que se lanzará. Luego se hace una llamada al
método startActivity (), pasando a través del objeto intención como argumento. Por ejemplo, el siguiente
fragmento de código emite una intención para la actividad con el nombre de la clase ActivityB para ser lanzado:
Intención i = new Intent (esto, ActivityB.class);

startActivity (i);
Los datos pueden ser transmitidos a la actividad receptora mediante la adición de al objeto intención antes de
que se inicia a través de llamadas al método putExtra () del objeto de la intención. Los datos deben ser añadidos
en forma de pares clave-valor. El siguiente código se extiende el ejemplo anterior para agregar valores de
cadena y enteros con las teclas "miCadena" y "myInt", respectivamente, a la intención:

i.putExtra ("miCadena", "Este es un mensaje para ActivityB");
i.putExtra ("myInt", 100);
startActivity (i);
Los datos se recibe en la actividad de destino como parte de un objeto Bundle que se puede obtener a través de
una llamada a getIntent (). GetExtras (). El método getIntent () de la clase Actividad devuelve la intención de que
comenzó la actividad, mientras que los getExtras método () (de la clase Intención) devuelve un objeto de
paquete para que la intención que contiene los datos. Por ejemplo, para extraer los valores de los datos
pasados a ActivityB:
Bundle extras = getIntent () getExtras (.);
Si (extras! = Null) {
Cadena miCadena = extras.getString ("miCadena");
int myInt = extras.getInt ("myInt");
}
Al utilizar las intenciones de lanzar otras actividades dentro de la misma aplicación, es esencial que esas
actividades se enumeran en el archivo de manifiesto de aplicación. Los siguientes contenidos
AndroidManifest.xml están configurados correctamente para una aplicación que contiene las actividades
nombradas ActivityA y ActivityB:

paquete = "com.ebookfrenzy.intent1.intent1">
<Application
android: label = "@ string / nombre_apl">
<Actividad
android: name = "com.ebookfrenzy.intent1.intent1.ActivityA">
<Categoría android: name = "android.intent.category.LAUNCHER" />
</ Actividad>
<Actividad
android: name = "ActivityB"
android: label = "ActivityB">
</ Actividad>
</ Application>
</ Manifiesto>
Devolver datos de una Actividad

Como el ejemplo de la sección gradas anteriores, mientras que los datos se transfieren a ActivityB, no hay
manera de que los datos se devuelven a la primera actividad (que llamaremos ActivityA). Esto puede, sin
embargo, se logrará mediante el lanzamiento de ActivityB como un sub-actividad de ActivityA. Una actividad se
inicia como un sub-actividad iniciando la intención con una llamada al método startActivityForResult () en lugar
de utilizar startActivity (). Además del objeto intención, este método también se pasa un valor de código de
solicitud que se puede utilizar para identificar los datos de retorno cuando regrese el sub-actividad. Por ejemplo:
startActivityForResult (i, REQUEST_CODE);
Con el fin de devolver los datos a la actividad de los padres, la subactividad debe implementar el método de
acabado (), cuyo propósito es crear un nuevo objeto de la intención que contiene los datos que se devuelve, y
luego llamar al método setResult () de la que encierra la actividad, pasando a través de un código de resultado y
la intención que contiene los datos de retorno. El código de resultado es típicamente RESULT_OK o
RESULT_CANCELED, pero también puede ser un valor personalizado con sujeción a los requisitos de la
promotora. En el caso de que se bloquea un sub-actividad, la actividad padre recibirá un código de resultado
RESULT_CANCELED.
El siguiente código, por ejemplo, ilustra el código de un típico acabado subactividad () método:
acabado public void () {

Los datos de intención = new Intent ();
data.putExtra ("returnString1", "Mensaje a la actividad principal");

setResult (RESULT_OK, de datos);
super.finish ();
}
Con el fin de obtener y extraer los datos devueltos, la actividad de los padres debe implementar el método
onActivityResult (), por ejemplo:
protegida onActivityResult void (int requestCode, int resultCode, los datos de

intención)
{
ReturnString Cadena;
si (resultCode == RESULT_OK && requestCode == REQUEST_CODE) {
si (data.hasExtra ("returnString1")) {
ReturnString = data.getExtras () getString ("returnString1.");
}
}
}
Tenga en cuenta que el método anterior comprueba el valor del código de petición vuelta para asegurarse de
que coincide con que pasó por el método () startActivityForResult. Al iniciar múltiples sub-actividades es
especialmente importante utilizar el código de solicitud para realizar un seguimiento que la actividad se
encuentra actualmente a la búsqueda, ya que todo se llame al método mismo onActivityResult () en la salida.
Intenciones implícitos
A diferencia de las intenciones explícitas, que hacen referencia al nombre de la clase Java de la actividad que
se lanzarán, las intenciones implícitas identificar la actividad que se lanzará al especificar la acción a realizar y el
tipo de datos que se maneja la actividad de recepción. Por ejemplo, un tipo de acción de ACTION_VIEW
acompañado de la URL de una página web en la forma de un objeto URI instruirá el sistema Android para
buscar, y posteriormente poner en marcha una actividad capaz navegador web. La siguiente intención implícita
será, cuando se ejecuta en un dispositivo Android, resultará en la página web designada que aparece en una
actividad del navegador web Chrome:
Intención i = new Intent (Intent.ACTION_VIEW,

Uri.parse ("http://www.ebookfrenzy.com"));
Cuando la intención implícita de arriba es emitida por una actividad, el sistema Android buscará actividades en
el dispositivo que se han registrado la capacidad de manejar las solicitudes ACTION_VIEW sobre los datos del
esquema HTTP mediante un proceso denominado resolución como intención. En el caso de que un solo partido
se encuentra, se pondrá en marcha esa actividad. Si se encuentra más de una coincidencia, el usuario se le
pedirá que elija entre las opciones de actividad disponibles.
El uso de Intención Filtros

Intención filtros son el mecanismo por el cual las actividades de "anuncian" acciones y datos soportados
capacidades de manejo en el proceso de resolución intención Android.Continuando con el ejemplo en la sección
anterior, una actividad capaz de mostrar páginas web incluiría una sección de filtro intención en su archivo de
manifiesto indicando apoyo a las solicitudes de intención tipo ACTION_VIEW sobre los datos del esquema http.
Es importante señalar que tanto las actividades de envío y recepción deben haber solicitado permiso para el tipo
de acción a realizar. Esto se logra mediante la adición de <usos-permisos> etiquetas a los archivos de
manifiesto de ambas actividades. Por ejemplo, las siguientes líneas de manifiesto piden permiso para acceder a
la base de datos de Internet y contactos:
<Usa-permiso android: name = "android.permission.READ_CONTACTS" />

El archivo AndroidManifest.xml siguiente ilustra una configuración para una actividad denominada
WebViewActivity con filtros intención y permisos activados para acceso a Internet:

paquete = "com.ebookfreny.WebView"
android: versionCode = "1"
android: VersionName = "1.0"?>
<Usa-Android SDK: minSdkVersion = "10" />
<Application
<Actividad
android: name = ". WebViewActivity">
<Acción android: name = "android.intent.action.VIEW" />
<Categoría android: name = "android.intent.category.DEFAULT" />
<Androide datos: scheme = "http" />
</ Actividad>
</ Application>
</ Manifiesto>
Comprobación de Intención disponibilidad

En general, es prudente suponer que una actividad estará disponible para un propósito en particular,
especialmente ya que la ausencia de una acción de juego normalmente como resultado la aplicación de
estrellarse. Afortunadamente, es posible identificar la disponibilidad de una actividad para una intención
específica antes de que se envía al sistema de tiempo de ejecución. El siguiente método se puede utilizar para
identificar la disponibilidad de una actividad para un tipo de acción intención especificado:
isIntentAvailable public static boolean (contexto Contexto, acción String) {

última PackageManager PackageManager = context.getPackageManager ();
intención Intención final = nuevo Intención (acción);
Lista <ResolveInfo> list =
packageManager.queryIntentActivities (intención,
PackageManager.MATCH_DEFAULT_ONLY);
volver list.size ()> 0;
}
Resumen
Intenciones son el mecanismo de mensajería mediante el cual una actividad Android puede lanzar otro. Una
intención explícita referencia a una actividad específica que se lanzará por referencia a la actividad de recepción
por nombre de la clase. Intentos explícitos son típicamente, aunque no exclusivamente, utiliza al iniciar las
actividades contenidas en la misma aplicación. Una intención implícita especifica la acción a realizar y el tipo de
datos para ser manipulados y permite que el tiempo de ejecución de Android encontrar una intención a juego
para lanzar. Intenciones implícitas se utilizan generalmente en el lanzamiento de las actividades que residen en
diferentes aplicaciones.
Una actividad puede enviar datos a la actividad de recepción por la agrupación de datos en el objeto de la
intención en forma de pares clave-valor. Los datos sólo se puede devolver desde una actividad si se inicia como
un sub-actividad de la actividad de envío.
Actividades anuncian capacidades al proceso de resolución de la intención de Android a través de la
especificación de la intención de los filtros en el archivo de manifiesto de aplicación. Ambas actividades que
envían y reciben también deben solicitar los permisos adecuados para realizar tareas tales como el acceso a la
base de datos de contactos del dispositivo o internet.
Después de haber cubierto la teoría de las intenciones, los próximos capítulos trabajarán a través de la creación
de algunos ejemplos en Android estudio que ponen las intenciones explícitas e implícitas en acción.
31 Intenciones explícitos Android - Un Estudio Android
Ejemplo
El capítulo titulado Una Visión General de Intenciones en Android estudio cubrió la teoría del uso de los destinos
para iniciar actividades. En este capítulo se pondrá en práctica esta teoría a través de la creación de una
aplicación de ejemplo.
El ejemplo de proyecto de aplicación Android estudio creado en este capítulo demostrará el uso de una
intención explícita para iniciar una actividad, incluida la transferencia de datos entre el envío y la recepción de
las actividades. El siguiente capítulo ( Intenciones implícitos Android - Un Ejemplo Android Estudio ) demostrará
el uso de las intenciones implícitas.
ación de la explícita intención Ejemplo de Aplicación

Lanzamiento Android Studio y crear un nuevo proyecto, entrando ExplicitIntent en el campo Nombre de la
aplicación y ebookfrenzy.com como el ajuste de dominio de la empresa antes de hacer clic en el botón
Siguiente.
actividad en blanco denominada ActivityA con una disposición correspondiente llamado activity_a.
Haga clic en Finalizar para crear el nuevo proyecto.
Diseño de la disposición de la interfaz de usuario para ActivityA

La interfaz de usuario para ActivityA consistirá en una vista RelativeLayout contiene EditarTexto (texto sin
formato), TextView y vistas botón denominado editText1, textView1 y el botón 1, respectivamente. Uso de la
ventana de la herramienta de proyectos, busque el archivo de recursos activity_a.xml para ActivityA (ubicado
bajo ExplicitIntent -> aplicación -> src -> principal -> res -> layout) y haga doble clic en él para cargarlo en la
herramienta Android Studio Designer. Cualquiera de diseñar la disposición en modo de diseño, o cambiar a
modo de texto e introduzca el siguiente código XML. Tenga en cuenta que el "Hacer Pregunta" texto que
aparece en la vista botón ha sido extraído de un recurso de cadena denominada ask_text.
Si el diseño de la interfaz de usuario usando la herramienta de diseño en modo de diseño, asegúrese de editar
el código XML después para agregar la propiedad manejador onClick para la vista el botón 1, y tenga en cuenta
la propiedad del ancho de la disposición del componente EditView se ha establecido en 200dp:

herramientas: context = ". ActivityA">
<TextView
android: text = "Texto grande"
<EditarTexto
android: layout_width = "200dp"
android: layout_above = "@ + / Identificación del textView1"
android: layout_marginBottom = "77dp" />
<Botón
android: text = "Hacer Pregunta"
android: layout_below = "@ + / Identificación del textView1"
</ RelativeLayout>
Como cubierto de una visión general y Android Estudio Ejemplo de Manejo Android Evento , el androide: onClick
= "onClick" línea de recursos en el listado XML anterior utiliza una forma alternativa para manejar eventos de clic
sencillas sin tener que implementar un detector de eventos en el código Java de la actividad. Al especificar el
tipo de evento onClick y el método que se llamará cuando se detecta un evento, es rápido y fácil de cablear
básico clic manejo de eventos en una vista. Una vez que el método onClick () se ha implementado en el archivo
ActivityA.java, será llamado cada vez que el botón es tocado por el usuario.
Una vez que el diseño es completa, la interfaz de usuario debe parecerse a la que se ilustra en la Figura 32-1:
Figura 32-1
Creación de la segunda clase de actividad

Cuando el botón "Hacer Pregunta" es tocado por el usuario, la intención será emitido solicitando que se puso en
marcha una segunda actividad en la que una respuesta puede ser introducido por el usuario. El siguiente paso,
por lo tanto, es crear la segunda actividad. Dentro de la ventana de la herramienta de proyectos, haga clic en el
nombre del paquete com.ebookfrenzy.explicitintent situado en ExplicitIntent -> aplicación -> src -> principal ->
Java y seleccione Nuevo -> Actividad -> opción de menú Actividad en blanco para mostrar la Nueva Actividad de
diálogo en blanco como se muestra en la Figura 32-2:
Figura 32-2
Introduzca ActivityB en los campos Nombre y título de la actividad y el nombre de la activity_b diseño. Debido a
que no se pondrá en marcha esta actividad cuando se inicia la aplicación (en su lugar se pondrá en marcha a
través de una intención por ActivityA cuando se pulsa el botón), es importante asegurarse de que la opción
Actividad Launcher está desactivada antes de hacer clic en el botón Finalizar.
Diseño de la disposición de la interfaz de usuario para ActivityB

Los únicos elementos que se requieren para la interfaz de usuario de la segunda actividad son un Texto sin
formato EditarTexto, TextView y vista Button. Con estos requisitos en mente, modificar el diseño activity_b.xml
en la herramienta de diseño, ya sea visualmente utilizando el modo de diseño o introduciendo directamente el
siguiente código XML en modo texto. Tenga en cuenta que el texto en el botón (que dice "Respuesta Pregunta")
ha sido extraído a un answer_text recurso de cadena que se llama:

herramientas: context = ". ActivityB">
<Botón
android: layout_below = "@ + / Identificación del editText1"
android: text = "@ string / answer_text" />
<TextView
android: text = "Texto grande"
<EditarTexto
android: layout_width = "300DP"
android: layout_below = "@ + / Identificación del textView1"
android: ems = "10"
android: InputType = "text" />
</ RelativeLayout>
Si el diseño del trazado con la herramienta de diseño en modo de diseño, tenga en cuenta que la propiedad
onClick en la opinión de botón se ha configurado para llamar a un método llamado onClick (), la anchura de la
vista EditarTexto se ha establecido en 300DP y las vistas se han asignado IDs Button1 TextView1 y
editText1. La disposición completado debe parecerse a la que se ilustra en la Figura 32-2:
Figura 32-3
Revisando el archivo de manifiesto de aplicación

Para que ActivityA para ser capaz de lanzar ActivityB usando una intención, es necesario que una entrada para
ActivityB estar presente en el archivo AndroidManifest.xml.Localizar el archivo dentro de la ventana de la
herramienta de proyectos, haga doble clic en él para cargarlo en el editor y verificar que Android Studio ha
añadido automáticamente una entrada para la actividad:

paquete = "com.ebookfrenzy.explicitintent">
<Application
<Actividad
android: name = ". ActivityA"

</ Actividad>
<Actividad
android: name = ". ActivityB"
android: label = "@ string / title_activity_activity_b">
</ Actividad>
</ Application>
</ Manifiesto>
Con la segunda actividad creada y que figuran en el archivo de manifiesto, ahora es tiempo para escribir algo de
código en la clase ActivityA emitir la intención.
Creación de la Intención
El objetivo para ActivityA es para crear e iniciar un intento cuando el usuario toca el botón "Hacer
Pregunta". Como parte del proceso de creación de la intención, se agregará la cadena pregunta introducida por
el usuario en la vista EditarTexto al objeto intención como un par clave-valor. Cuando se creó el diseño de la
interfaz de usuario para ActivityA, el objeto de botón se ha configurado para llamar a un método llamado onClick
() cuando "clic" por el usuario. Este método necesita ahora para ser añadido al archivo de origen ActivityA.java
clase ActivityA como sigue:
com.ebookfrenzy.explicitintent paquete;
android.content.Intent importación;
public class ActivityA extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_a);
}
public void onClick (Ver vista) {
última EditarTexto editText1 = (EditarTexto)

findViewById (R.id.editText1);
. Cadena miCadena = editText1.getText toString () ();
i.putExtra ("QString", miCadena);
startActivity (i);
}
.
.
.
}
El código para el método onClick () sigue las técnicas descritas en una visión general de Intenciones
Android. En primer lugar, se crea una nueva instancia de Intención, que pasa a través de la actividad actual y el
nombre de la clase de ActivityB como argumentos. A continuación, el texto introducido en el objeto EditarTexto
se añade al objeto intención como un par clave-valor y la intención inicia a través de una llamada a startActivity
(), pasando a través del objeto intención como argumento.
Compila y ejecuta la aplicación y pulse el botón "Hacer Pregunta" para iniciar ActivityB y el botón Atrás para
volver a ActivityA.
La extracción de los datos de intención

Ahora que ActivityB está siendo lanzado desde ActivityA, el siguiente paso es extraer el valor de datos de
Cuerda incluido en la intención y asignarlo al objeto TextView en la interfaz de usuario ActivityB. Esto implica
agregar algo de código para el método de ActivityB onCreate () en el archivo de origen ActivityB.java:
com.ebookfrenzy.explicitintent paquete;
public class ActivityB extiende Actividad {

setContentView (R.layout.activityb);
Bundle extras = getIntent () getExtras (.);

if (extras == null) {
volver;
}
Cadena QString = extras.getString ("QString");
última TextView TextView = (TextView)

findViewById (R.id.textView1);
textView.setText (QString);
}
}
Compila y ejecuta la aplicación, ya sea dentro de un emulador o en un dispositivo Android física. Escriba una
pregunta en el cuadro de texto en ActivityA antes de tocar el botón "Hacer Pregunta". La pregunta debería
aparecer ahora en el componente TextView en la interfaz de usuario ActivityB.
Lanzamiento ActivityB como Sub-Actividad

Para que ActivityB para poder devolver datos a ActivityA, ActivityB debe iniciarse como un sub-actividad de
ActivityA. Esto significa que la llamada a startActivity () en el método ActivityA onClick () necesita ser
reemplazado con una llamada a startActivityForResult (). A diferencia del método startActivity (), que toma sólo
el objeto intención como argumento, startActivityForResult () requiere que un código de solicitud también puede
pasar a través. El código de petición puede ser cualquier valor numérico y se utiliza para identificar qué sub-
actividad está asociada con qué conjunto de datos de retorno. A los efectos de este ejemplo, se utilizará un
código de solicitud de 5, que nos da una clase ActivityA modificado que dice lo siguiente:
public class ActivityA extiende ActionBarActivity {
private static int request_code final = 5;
@ Override
setContentView (R.layout.main);
}
última EditarTexto editText1 = (EditarTexto)

findViewById (R.id.editText1);
. Cadena miCadena = editText1.getText toString () ();
i.putExtra ("QString", miCadena);
startActivityForResult (i, request_code);
}
}
Cuando las salidas sub-actividad, el método onActivityResult () de la actividad de los padres se llama y se pasan
como argumentos el código de solicitud asociada con la intención, un código de resultado que indica el éxito o
no de la subactividad y un objeto que contiene toda la intención de datos devuelta por la
subactividad. Continuando todavía en el archivo de origen de clase ActivityA, este método debe aplicarse de la
siguiente manera:
protegida onActivityResult void (int requestCode, int resultCode, los datos de

intención) {
if ((requestCode == request_code) &&
(ResultCode == RESULT_OK)) {
TextView textView1 =
(TextView) findViewById (R.id.textView1);
Cadena ReturnString =
data.getExtras () getString ("returnData.");
textView1.setText (ReturnString);
}
}
El código en el método anterior comienza comprobando que el código de solicitud coincide con la utilizada
cuando se emitió la intención y asegurándose de que la actividad se ha realizado correctamente. Los datos de
rentabilidad se extrae de la intención y se muestra en el objeto TextView.
Devolver datos de un Sub-Actividad

ActivityB ahora se lanzó como un sub-actividad de ActivityA, que ha su vez ha modificado para manejar datos
devueltos por ActivityB. Todo lo que queda es modificar ActivityB.java para implementar el método de acabado
() y añadir código para el método onClick (), que se llama cuando se toca el botón "Responder a la pregunta". El
método de acabado () se activa cuando una sale de actividad (por ejemplo, cuando el usuario selecciona el
botón de retroceso en el dispositivo):

acabado ();
}
@ Override
acabado public void () {
Los datos de intención = new Intent ();
EditarTexto editText1 = (EditarTexto) findViewById (R.id.editText1);
. Cadena ReturnString = editText1.getText toString () ();

data.putExtra ("returnData", ReturnString);
setResult (RESULT_OK, de datos);

super.finish ();
}
Todo lo que el método de acabado () necesita hacer es crear un nuevo intento, agregar los datos de retorno
como un par clave-valor y luego llamar al método setResult (), pasando a través de un código de resultado y el
objeto intención. El método onClick () simplemente llama al método acabado ().
Compila y ejecuta la aplicación, escriba una pregunta en el campo de texto en ActivityA y toque el botón "Hacer
Pregunta". Cuando aparezca ActivityB, introduzca la respuesta a la pregunta y utilizar el botón Atrás o el botón
"Enviar respuesta" para volver a ActivityA donde la respuesta debe aparecer en el objeto de visualización de
texto.
Resumen
Después de haber cubierto los conceptos básicos de las intenciones en el capítulo anterior, el objetivo de este
capítulo ha sido la de trabajar a través de la creación de un proyecto de aplicación en Android Estudio diseñado
para demostrar el uso de las intenciones explícitas, junto con los conceptos de transferencia de datos entre una
actividad y padres subactividad.
El siguiente capítulo trabajará a través de un ejemplo diseñado para demostrar las intenciones implícitas en la
acción.
32 Intenciones implícitos Android - Un Estudio Android

Ejemplo
En este capítulo, una aplicación de ejemplo se creará en Android Estudio diseñado para demostrar una
aplicación práctica de las intenciones implícitas. El objetivo será el de crear y enviar un propósito solicitando que
el contenido de una página web en particular se carga y se muestra al usuario. Desde la aplicación de ejemplo
en sí mismo no contendrá una actividad capaz de realizar esta tarea, se emitirá una intención implícita de modo
que el algoritmo de resolución de intención Android puede ser contratado para identificar y poner en marcha una
actividad adecuada desde otra aplicación. Esto es más probable que sea una actividad desde el navegador web
Chrome incluido con el sistema operativo Android.
Después de haber lanzado con éxito el navegador integrado, se creará un nuevo proyecto que también contiene
una actividad capaz de mostrar páginas web. Esto se va a instalar en el dispositivo o emulador y se utiliza para
demostrar lo que sucede cuando dos actividades se ajustan a los criterios de una intención implícita.
ear el Android Estudio implícito Intención Proyecto Ejemplo

Lanzamiento Android Studio y crear un nuevo proyecto, entrando ImplicitIntent en el campo Nombre de la
Siguiente.
actividad en blanco denominada ImplicitIntentActivity con una disposición correspondiente llamado
activity_implicit_intent.
Haga clic en Finalizar para crear el nuevo proyecto.

La interfaz de usuario para la clase ImplicitIntentActivity es muy simple, que consiste únicamente en una vista
RelativeLayout y un botón. Dentro de la ventana de la herramienta de proyectos, busque el ImplicitIntent ->
aplicación -> src -> principal -> res -> diseño - archivo> activity_implicit_intent.xml y haga doble clic en él para
cargarlo en la herramienta Diseñador. Visualmente construir la interfaz de usuario en modo de diseño para que
se asemeja la figura 33-1, o introduzca el siguiente XML en modo texto. Nótese que en ambos casos, el texto en
el botón ("Show Página Web") ha sido extraído de un recurso de cadena denominada button_text:

herramientas: context =
"com.ebookfrenzy.implicitintent.ImplicitIntentActivity">
<Botón
android: text = "@ string / button_text"
android: onClick = "showWebPage" />
</ RelativeLayout>
Figura 33-1
Tenga en cuenta la inclusión de la propiedad onClick que asegurará que un método llamado showWebPage ()
(que aún no ha sido implementado) será llamada cuando el botón está "clic" por el usuario.
Creación de la Intención Implícita

Como se ha señalado anteriormente, la intención implícita será creado y emitido desde dentro de un método
llamado showWebPage () que, a su vez, necesita ser implementado en la clase ImplicitIntentActivity, el código
para que reside en el archivo de origen ImplicitIntentActivity.java. Localizar el archivo en la ventana de
herramientas del proyecto y haga doble clic en él para cargarlo en un panel de edición. Una vez cargado,
modificar el código para agregar el método showWebPage () junto con algunas importaciones necesarias:
com.ebookfrenzy.implicitintent paquete;
android.net.Uri importación;
public class ImplicitIntentActivity extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_implicit_intent);
}
public void showWebPage (Ver vista) {
Intención Intención = new Intent (Intent.ACTION_VIEW,
Uri.parse ("http://www.ebookfrenzy.com"));
startActivity (intención);
}
.
.
.
}
Las tareas realizadas por este método son realmente muy simple. En primer lugar, se crea un nuevo objeto de la
intención. En lugar de especificar el nombre de clase de la intención, sin embargo, el código simplemente indica
la naturaleza de la intención (para mostrar algo que el usuario) mediante la opción ACTION_VIEW. El objeto
intención también incluye un URI que contiene la URL que se mostrará. Esto indica que el sistema de resolución
de intención Android que la actividad está solicitando que se mostrará una página web. La intención se emite a
través de una llamada al método startActivity ().
Compila y ejecuta la aplicación en ambos un emulador o en un dispositivo Android física y, una vez en
funcionamiento, toque el botón Mostrar Página Web. Al tocarla, una vista del navegador web debe aparecer y
cargar la página web designada por la URL. Una intención implícita éxito ahora se ha ejecutado.
Adición de una segunda actividad Matching

El resto de este capítulo se utilizará para demostrar el efecto de la presencia de más de una actividad instalado
en el dispositivo de búsqueda de los requisitos para una intención implícita. Para lograr esto, una segunda
aplicación se creará y se instala en el dispositivo o emulador. Comience tanto, mediante la creación de un
proyecto nuevo en Android Studio con el nombre de la aplicación se establece en MyWebView usando las
posibilidades de configuración misma SDK utilizados al crear el proyecto ImplicitIntent anteriormente en este
capítulo. Seleccione una actividad en blanco y, cuando se le solicite, el nombre de la actividad y la
MyWebViewActivity activity_my_web_view diseño.
Adición de la web Ver en la interfaz de usuario

La interfaz de usuario de la única actividad que figura en el nuevo proyecto MyWebView va a consistir en una
instancia del widget WebView Android. Dentro de la ventana de la herramienta de proyectos, busque el archivo
activity_my_web_view.xml contiene la descripción de interfaz de usuario para la actividad y haga doble clic en él
para cargarlo en la herramienta Diseñador. Con la herramienta de diseño en modo Diseño, seleccione el widget
predeterminado TextView y sacarlo de la disposición con la tecla Suprimir del teclado. Interruptor Designer para
el modo de texto y editar el XML para eliminar las propiedades de relleno TextView y elemento para que el
archivo es el siguiente:

herramientas: context = ". MyWebViewActivity">
</ RelativeLayout>
Retorno a la herramienta Diseñador de modo y arrastre Diseño y soltar un objeto WebView de la sección
Widgets de la paleta en la vista RelativeLayout existente. Ajuste la altura de diseño y las propiedades de
anchura a match_parent ya sea utilizando botones de la barra de diseño o el panel Propiedades para que el
WebView llena todo el área de visualización, como se ilustra en la Figura 33-2:
Figura 33-2
Haga doble clic en la instancia WebView y cambiar el ID de @ + / Identificación del webView1.
La obtención de la URL Intención

Cuando se crea el objeto intención implícita para mostrar una ventana del navegador web, la URL de la página
web que se muestra se incluirá en el objeto de la intención en un objeto de Uri. La tarea del método onCreate ()
dentro de la clase MyWebViewActivity es extraer esta Uri del objeto intención, convertirlo en una cadena URL y
asignarlo al objeto WebView. Para implementar esta funcionalidad, modificar el método onCreate () en
MyWebViewActivity.java para que se lea de la siguiente manera:
com.ebookfrenzy.mywebview paquete;
java.net.URL importación;
android.net.Uri importación;
android.webkit.WebView importación;
public class MyWebViewActivity extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_my_web_view);
Intención Intención = getIntent ();
Datos Uri = intent.getData ();

Url URL = null;
try {
url = new URL (data.getScheme (),
data.getHost (),
data.getPath ());
} Catch (Exception e) {
e.printStackTrace ();
}
WebView web View = (WebView) findViewById (R.id.webView1);

webView.loadUrl (url.toString ());
}
}
El nuevo código añade a la onCreate () método realiza las siguientes tareas:
 Obtiene una referencia a la intención que causó esta actividad que se puso en marcha
 Extrae los datos Uri del objeto intención
 Convierte los datos de Uri a un objeto URL
 Obtiene una referencia al objeto WebView en la interfaz de usuario
 Carga la URL a la vista web, la conversión de la URL en una cadena en el proceso
La parte de codificación del proyecto MyWebView ha finalizado. Todo lo que queda es modificar el archivo de
manifiesto.
Modificación del archivo MyWebView Proyecto Manifiesto

Hay una serie de cambios que se deben hacer para el archivo de manifiesto MyWebView antes de que pueda
ser probado. En el primer caso, se necesitará la actividad que pedir permiso para acceder a Internet (ya que
tendrá que cargar una página web). Esto se logra mediante la adición de la línea de permiso apropiado para el
archivo de manifiesto:
Además, una revisión de los contenidos de la sección de filtro intención del archivo AndroidManifest.xml para el
proyecto MyWebView revelará los siguientes ajustes:
En el XML anterior, la entrada android.intent.action.MAIN indica que esta actividad es el punto de entrada de la
aplicación cuando se puso en marcha sin ninguna entrada de datos. La directiva
android.intent.category.LAUNCHER, por otra parte, indica que la actividad debe aparecer dentro de la pantalla
del iniciador de la aplicación del dispositivo.
Debido a que no se requiere la actividad que se lanzará como punto de entrada a una aplicación, no se puede
ejecutar sin entrada de datos (en este caso una URL) y no está obligado a aparecer en el programa de
lanzamiento, ni las directivas PRINCIPALES ni LANZADOR se requieren en el archivo de manifiesto para esta
actividad.
El filtro de intención para la actividad MyWebViewActivity hace, sin embargo, necesita ser modificado para
indicar que es capaz de manejar ACTION_VIEW acciones intención aplicables a los regímenes de datos
http. Android también requiere que todas las actividades capaces de manejar las intenciones implícitas que no
incluyen las entradas principales y el lanzador también incluyen la denominada categoría por defecto en el filtro
de la intención. La sección de filtro intención modificada debe, por lo tanto, que diga lo siguiente:
<Categoría android: name = "android.intent.category.DEFAULT" />
La combinación de estos requisitos juntos los resultados en el siguiente archivo AndroidManifest.xml completo:

paquete = "com.ebookfrenzy.mywebview">
<Application
<Actividad
android: ". MyWebViewActivity" name =
<Categoría
android: name = "android.intent.category.DEFAULT" />
</ Actividad>
</ Application>
</ Manifiesto>
Cargue el archivo AndroidManifest.xml en el editor de manifiesto haciendo doble clic sobre el nombre del archivo
en la ventana de herramientas del proyecto. Una vez cargado, modificar el XML para que coincida con los
cambios anteriores. Después de haber hecho las modificaciones apropiadas en el archivo de manifiesto, la
nueva actividad está listo para ser instalado en el dispositivo.
Instalación del paquete MyWebView en un dispositivo

Antes de la MyWebViewActivity se puede utilizar como receptor de una intención implícita, primero se debe
instalar en el dispositivo. Esto se logra mediante la ejecución de la aplicación de la manera normal. Debido a
que el archivo de manifiesto no contiene ni la android.intent.action.MAIN ni las directivas
android.intent.category.LAUNCHER, sin embargo, Android Estudio no sabe si debe o no iniciar la actividad una
vez que la aplicación se ha instalado en el dispositivo. En consecuencia, Android Estudio mostrará el cuadro de
diálogo Editar configuración se ilustra en la Figura 33-3 cuando se ejecuta la aplicación, solicitando instrucciones
sobre cómo proceder una vez que el paquete de la aplicación se ha instalado.
Figura 33-3
Dentro de la sección Actividad del diálogo de configuración, seleccione la opción No poner en marcha la
actividad de manera que se ha instalado la actividad pero no se iniciará y haga clic en el botón Ejecutar. La
instalación correcta del paquete se informó en la ventana de la herramienta Android Estudio Run:
Instalación com.ebookfrenzy.mywebview
DISPOSITIVO shell de comandos: pm instalar -r
"/data/local/tmp/com.ebookfrenzy.mywebview.mywebview"
pkg: /data/local/tmp/com.ebookfrenzy.mywebview
Éxito
Una vez completada la instalación, la actividad está listo para ser incluido en el proceso de resolución de la
intención del marco Android.
Con el fin de probar MyWebView, simplemente vuelva a iniciar la aplicación ImplicitIntent creado anteriormente
en este capítulo y toque el botón Mostrar Página Web. Esta vez, sin embargo, el proceso de resolución de
intención encontrará dos actividades con filtros intención que concuerden con la intención implícita. Como tal, el
sistema mostrará un cuadro de diálogo (Figura 33-4) proporcionar al usuario la elección de la actividad para
lanzar.
Figura 33-4
Al seleccionar la opción MyWebView seguido del botón Sólo una vez debería hacer que la intención de ser
manejado por nuestro nuevo MyWebViewActivity, que posteriormente aparecerá y mostrará la página web
designada.
Si la página web se carga en el navegador Chrome sin el diálogo de selección que aparece más arriba, puede
ser que Chrome se ha configurado como el navegador por defecto en el dispositivo. Esto se puede cambiar por
ir a Ajustes -> Aplicaciones en el dispositivo y elegir la categoría TODOS. Desplácese por la lista de
aplicaciones y seleccione Chrome. En la pantalla de la aplicación información Chrome, toque el botón Borrar
valores predeterminados.
Resumen
Intenciones implícitas proporcionan un mecanismo por el cual una actividad se puede solicitar el servicio de otro
simplemente especificando un tipo de acción y, opcionalmente, los datos en que esa acción se va a
realizar. Con el fin de ser elegible como candidato blanco de una intención implícita, sin embargo, una actividad
debe estar configurado para extraer los datos correspondientes del objeto intención entrante y se incluirán en un
fichero de manifiesto configurado correctamente, incluyendo los permisos adecuados y filtros intención. Cuando
se encuentra más de una actividad coincidente para una intención implícita durante una búsqueda resolución
intención, se solicita al usuario que tomar una decisión en cuanto a cuál usar.
Dentro de este capítulo un ejemplo ha sido creado para demostrar tanto la emisión de una intención implícita,
así como la creación de una actividad ejemplo capaz de manejar esa intención.
33 Broadcast Intenciones (Intents) y receivers de
radiodifusión en Android Estudio
Además de proporcionar un mecanismo para el lanzamiento de las actividades de aplicación, los intentos
también se utilizan como una forma de transmitir ancho mensajes del sistema a otros componentes en el
sistema. Esto implica la implementación de Broadcast Intenciones y receptores de radiodifusión, los cuales son
el tema de este capítulo.
Una visión general de Difusión Intenciones

Intentos de difusión son objetos Intención que se emiten a través de una llamada a los sendBroadcast (),
sendStickyBroadcast () o sendOrderedBroadcast () de la clase de actividad (utilizándose esta última cuando se
requieren resultados de la emisión). Además de proporcionar un sistema de mensajería y eventos entre los
componentes de aplicaciones, los intentos de difusión también son utilizados por el sistema Android para
notificar a las aplicaciones interesadas acerca de los eventos del sistema clave (como la fuente de alimentación
externa o auriculares están conectados o desconectados).
Cuando se crea un intento de difusión, debe incluir una cadena de acción además de los datos opcionales y una
cadena de categoría. Al igual que con las intenciones estándar, se añade datos a una intención difusión usando
pares de valores clave en conjunción con el método putExtra () del objeto de la intención. La categoría de
cadena opcional se puede asignar a una intención de difusión a través de una llamada al método AddCategory
().
La cadena de acción, que identifica el evento de difusión, debe ser único y por lo general utiliza la sintaxis de
Java nombre del paquete de la aplicación. Por ejemplo, el siguiente fragmento de código crea y envía un intento
de difusión que incluye una cadena de acción único y los datos:
Intención Intención = new Intent ();

intent.setAction ("com.example.Broadcast");
intent.putExtra ("MyData", 1000);
sendBroadcast (intención);
El código anterior podría lanzar con éxito el receptor de difusión correspondiente en un dispositivo que ejecuta
una versión anterior a la 3.0 de Android. En las versiones más recientes de Android, sin embargo, la intención
no sería recibida por el receptor de radiodifusión. Esto se debe a Android 3.0 introdujo una medida de seguridad
de control de lanzamiento que impide que los componentes de las aplicaciones dejado de ser puesto en marcha
a través de una intención. Una aplicación se considera que está en un estado detenido si el caso ha sido o bien
simplemente se instala y no lanzado previamente, o ha detenido manualmente por el usuario mediante el gestor
de aplicaciones en el dispositivo. Para evitar esto, sin embargo, una bandera se puede añadir a la intención
antes de que se envía para indicar que la intención es que se le permita iniciar un componente de una aplicación
detenido. Esta bandera es FLAG_INCLUDE_STOPPED_PACKAGES y se utilizaría como se indica en la
siguiente adaptación del fragmento de código anterior:

intent.addFlags (Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
intent.setAction ("com.example.Broadcast");
intent.putExtra ("MyData", 1000);
Una visión general de los receptores de radiodifusión

Una aplicación a la escucha de las intenciones de difusión específicas mediante el registro de un receptor de
radio. Receptores de radiodifusión se implementan mediante la ampliación de la clase Android
BroadcastReceiver y reemplazando el método OnReceive (). El receptor de radiodifusión puede entonces ser
registrado, ya sea en el código (por ejemplo dentro de una actividad), o dentro de un archivo de
manifiesto. Parte de la aplicación de registro consiste en la creación de filtros de intención para indicar las
intenciones de emisión específicos se requiere que el receptor para escuchar. Esto se logra haciendo referencia
a la cadena de acción de la intención de difusión. Cuando se detecta una emisión a juego, se llama al método
OnReceive () del receptor de radiodifusión, momento en el que el método tiene 5 segundos de tiempo para
llevar a cabo las tareas necesarias antes de regresar. Es importante tener en cuenta que un receptor de
radiodifusión no necesita estar funcionando todo el tiempo. En el caso de que se detecte un intento coincidente,
el sistema de ejecución de Android se iniciará automáticamente el receptor de radiodifusión antes de llamar al
método OnReceive ().
El código siguiente se aprecia una plantilla Receptor Broadcast subclase:
com.example.broadcastdetector paquete;
android.content.BroadcastReceiver importación;
android.content.Context importación;
public class MyReceiver extiende BroadcastReceiver {
MyReceiver público () {
}
@ Override
public void OnReceive (contexto Contexto, intención Intención) {
// Implementar código aquí a realizar cuando
// Se detecta emisión
}
}
Al registrar un receptor de emisiones dentro de un archivo de manifiesto, hay que añadir un <receiver> entrada
que contenga uno o más filtros de intención, cada uno con la cadena de acción de la intención de difusión para
el que se requiere que el receptor para escuchar.
El siguiente archivo de manifiesto de ejemplo registra el receptor ejemplo emisión de arriba para escuchar las
intenciones de difusión que contienen una cadena de acción de com.example.Broadcast:

paquete = "com.example.broadcastdetector.broadcastdetector"
android: versionCode = "1"
android: VersionName = "1.0"?>
<Usa-Android SDK: minSdkVersion = "17" />
<Application
<Androide receptor: name = "MyReceiver">
<Acción android: name = "com.example.Broadcast">
</ Accion>
</ Receptor>
</ Application>
</ Manifiesto>
El mismo efecto se puede lograr mediante el registro de la emisión en el receptor de código usando el método
registerReceiver () de la clase Actividad junto con un objeto IntentFilter configurado apropiadamente:
IntentFilter filtro = new IntentFilter ("com.example.Broadcast");
MyReceiver receptor = new MyReceiver ();

registerReceiver (receptor, filtro);
Cuando ya no se requiere un receptor de emisiones registradas en el código, se puede no registrado a través de

una llamada al método unregisterReceiver () de la clase de actividad, pasando por una referencia al objeto
receptor como argumento. Por ejemplo, el siguiente código anular el registro del receptor de radiodifusión
anteriormente:
unregisterReceiver (receptor);
Es importante tener en cuenta que algunos intentos de difusión del sistema sólo pueden ser detectadas por un
receptor de emisiones si se ha registrado en el código en lugar de en el archivo de manifiesto. Compruebe la
documentación de la clase Intención Android para obtener una descripción detallada de los intentos de difusión
del sistema y los requisitos correspondientes en línea en:
http://developer.android.com/reference/android/content/Intent.html
La obtención de resultados a partir de un Broadcast

Cuando se envía un intento de difusión utilizando el método sendBroadcast (), no hay manera para la actividad
de iniciación para recibir los resultados de cualquier receptores de radiodifusión que recogen la emisión. En el
caso de que se requieren resultados de retorno, es necesario utilizar el método sendOrderedBroadcast () en su
lugar. Cuando se envía un intento de difusión utilizando este método, se entrega en orden secuencial a cada
receptor de radiodifusión con un interés registrado.
El método sendOrderedBroadcast () se llama con una serie de argumentos, incluyendo una referencia a otro
receptor de radiodifusión (conocido como el receptor de resultado), que es para ser notificado cuando todos los
demás receptores de radiodifusión han manejado la intención, junto con un conjunto de referencias de datos en
la que los receptores pueden colocar datos de resultados. Cuando todos los receptores de radiodifusión se les
ha dado la oportunidad de manejar la emisión, el método OnReceive () del receptor resultado se llama y se pasa
los datos del resultado.
Sticky Broadcast Intenciones

De forma predeterminada, los intentos de difusión desaparecen una vez que se han enviado y manejado por
cualquier receptores de radiodifusión interesados. Un intento de difusión puede, sin embargo, se define como
"pegajoso". Una intención pegajosa, y los datos contenidos en el mismo, permanece presente en el sistema
después de que se ha completado. Los datos almacenados en un intento emisión persistente se pueden obtener
a través del valor de retorno de una llamada al método registerReceiver (), utilizando los argumentos habituales
(referencias al receptor de radiodifusión y los objetos de filtro intención). Muchas de las transmisiones del
sistema Android son pegajoso, un buen ejemplo siendo esas emisiones relacionadas con el estado de nivel de
batería.
Una emisión persistente puede ser removido en cualquier momento por medio de una llamada al método
removeStickyBroadcast (), pasando por como argumento una referencia a la intención de difusión para ser
eliminado.
El Ejemplo Broadcast Intención

El resto de este capítulo se trabajará a través de la creación de un ejemplo basado en Android Estudio de
intentos de difusión en acción. En el primer caso, una sencilla aplicación será creado con el propósito de emitir
un intento transmitir personalizado. Un receptor de radiodifusión correspondiente será entonces creada que
mostrará un mensaje en la pantalla del dispositivo Android cuando se detecta la emisión. Por último, el receptor
de radiodifusión será modificado para detectar la notificación por el sistema que la energía externa se ha
desconectado del dispositivo.

Lanzamiento Android Studio y crear un nuevo proyecto, entrando SendBroadcast en el campo Nombre de la
Siguiente.
actividad en blanco denominada SendBroadcastActivity con una disposición correspondiente llamado
activity_send_broadcast.
Una vez que el nuevo proyecto se ha creado, localizar y cargar el archivo de diseño activity_send_broadcast.xml
situado en la ventana de herramientas Proyecto en SendBroadcast -> aplicación -> src -> principal -> res ->
diseño y, con la herramienta de diseño en modo de diseño, reemplazar el objeto TextView con miras
Button. Mueva el botón para el centro de la pantalla, haga doble clic en él y establecer la propiedad de texto
para que diga "Enviar Broadcast". Una vez que el valor de texto ha sido definida, use el icono de menú bombilla
para extraer la cadena en un button_text recurso con nombre.
Con aún seleccionado el botón en el diseño, busque la propiedad onClick en el panel Propiedades y configurarlo
para llamar a un método llamado broadcastIntent. Un atajo útil para la búsqueda de propiedades es hacer clic en
la barra de herramientas del panel Propiedades y empezar a escribir los primeros caracteres del nombre de la
propiedad. Esto hará que el sistema de búsqueda y comenzar a seleccionar los mejores partidos para el nombre
de la propiedad.
Creación y envío de la Intención Broadcast
Después de haber creado el marco para la aplicación SendBroadcast, ahora es el momento de implementar el
código para enviar la intención de difusión. Esto implica la realización del procedimiento broadcastIntent ()
previamente especificado como destino onClick del botón de vista de la interfaz de usuario. Busque y haga
doble clic en el archivo SendBroadcastActivity.java y modificarlo para añadir el código para crear y enviar la
intención de difusión. Una vez modificado, el código fuente de esta clase debería decir lo siguiente:
com.ebookfrenzy.sendbroadcast paquete;
public class SendBroadcastActivity extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_send_broadcast);
}
public void broadcastIntent (Ver vista)

{
intent.setAction ("com.ebookfrenzy.sendbroadcast");
intent.addFlags (Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
}
.
.
.
}
Tenga en cuenta que, en este caso, la cadena de acción para la intención es

com.ebookfrenzy.sendbroadcast. Cuando se crea la clase receptor de radiodifusión en secciones posteriores de
este capítulo, es esencial que la declaración de filtro intención coincide con esta cadena de acción.
Esto concluye la creación de la aplicación para enviar la intención de difusión. Todo lo que queda es la
construcción de un receptor de juego.
Crear el Receptor Broadcast

Con el fin de crear el receptor de radiodifusión, una nueva clase tiene que ser creado que las subclases de la
superclase BroadcastReceiver. Crear un nuevo proyecto con el nombre del conjunto de aplicaciones para
BroadcastReceiver y el nombre de dominio de la empresa establecida en com.ebookfrenzy, esta vez
seleccionando la opción Agregar Sin actividad antes de hacer clic en Finalizar.
Dentro de la ventana de herramientas del proyecto, vaya a BroadcastReceiver -> aplicación -> src -> principal ->
Java y clic derecho sobre el nombre del paquete. En el menú que aparece, seleccione Nuevo -> Otros -> opción
de menú Receptor Broadcast, nombre el MyReceiver clase y asegurarse de que las opciones exportados y
habilitados son seleccionados.
Una vez creado, Android Estudio cargará automáticamente el nuevo archivo de clase MyReceiver.java en el
editor en el que se leerá como sigue:
com.ebookfrenzy.broadcastreceiver paquete;
}
@ Override
// TODO: Este método se llama cuando el BroadcastReceiver está recibiendo
// Una emisión de Intención.
throw new UnsupportedOperationException ("Todavía no implementado");
}
}
Como puede verse en el código, Android Studio ha generado una plantilla para la nueva clase y generado un
stub para el método OnReceive (). Ahora deben hacerse a la clase para implementar el comportamiento
requerido una serie de cambios. Permanecer en el archivo MyReceiver.java, por lo tanto, modificar el código
para que se lea de la siguiente manera:
com.ebookfrenzy.broadcastreceiver paquete;
}
@ Override
Toast.makeText (contexto, "Broadcast Intención Detectado.",

Toast.LENGTH_LONG) .show ();
}
El código para el receptor de radiodifusión se ha completado.
Configuración de un receptor de radiodifusión en el archivo de manifiesto

En común con otros proyectos para Android, BroadcastReceiver ha asociado un fichero de manifiesto llamado
AndroidManifest.xml.
Este archivo debe dar a conocer la presencia del receptor de emisiones y debe incluir un filtro intención de
especificar los intentos de difusión en la que el receptor se encuentra interesado. Cuando la clase
BroadcastReceiver fue creado en la sección anterior, Android estudio añade automáticamente a <Receptor>
para el archivo de manifiesto. Todo lo que queda, por lo tanto, es añadir un <intención de filtro> elemento dentro
del <receiver> Declaración apropiadamente configurado para la cadena de acción personalizado:

paquete = "com.ebookfrenzy.broadcastreceiver.broadcastreceiver">
<Application
<Receptor
android: name = ". MyReceiver"
android: enabled = "true"
android: exportado = "true">
<Acción
android: name = "com.ebookfrenzy.sendbroadcast">
</ Accion>
</ Receptor>
</ Application>
</ Manifiesto>
Con el archivo de manifiesto completado, el ejemplo de difusión está listo para ser probado.
Probando el Ejemplo Broadcast

Con el fin de probar el emisor y el receptor de radiodifusión, comienza ejecutando la aplicación de
BroadcastReceiver en un dispositivo Android física. Cuando aparezca el cuadro de diálogo Editar configuración,
seleccione la opción No poner en marcha la actividad de manera que se ha instalado la actividad, pero no en
marcha y haga clic en el botón Ejecutar. La instalación correcta del paquete se informó en la ventana de la
herramienta Android Estudio Run:
Carga de archivos
ruta local: C: \ Users \ Neil \ AndroidStudioProjects \
BroadcastReceiver \ app \ build \ salidas \ apk \ app-debug.apk
ruta remota: /data/local/tmp/com.ebookfrenzy.broadcastreceiver
Instalación com.ebookfrenzy.broadcastreceiver
DISPOSITIVO shell de comandos: pm instalar -r
"/data/local/tmp/com.ebookfrenzy.broadcastreceiver"
pkg: /data/local/tmp/com.ebookfrenzy.broadcastreceiver
Éxito
Una vez instalado el receptor, ejecute la aplicación SendBroadcast en el mismo dispositivo o AVD y esperar a
que aparezca en la pantalla. Una vez en funcionamiento, toque el botón, momento en el que el mensaje de la
tostada de leer "Intención Broadcast Detectado." Debería aparecer durante unos segundos antes de
desaparecer.
En el caso de que no aparezca el mensaje tostadas, vuelve a comprobar que la aplicación BroadcastReceiver
instalado correctamente y que el filtro de la intención en el archivo de manifiesto coincide con la cadena de
acción se utiliza cuando se transmitió la intención.
Escuchando transmisiones del sistema

La etapa final de este ejemplo es modificar el filtro de intención para la BroadcastReceiver escuchar también por
la intención del sistema que se emite cuando la alimentación externa está desconectada del dispositivo. La
acción que el receptor tiene que estar escuchando en este contexto es
android.intent.action.ACTION_POWER_DISCONNECTED.El archivo de manifiesto modificado para el proyecto
BroadcastReceiver debe, por lo tanto, ahora se lea como sigue:

paquete = "com.ebookfrenzy.broadcastreceiver.broadcastreceiver">
<Androide aplicación: allowBackup = "true"

<Receptor
android: name = ". MyReceiver"
<Acción
android: name = "com.ebookfrenzy.sendbroadcast">
</ Accion>
<Acción
android: name = "android.intent.action.ACTION_POWER_DISCONNECTED">
</ Accion>

</ Receptor>
</ Application>
</ Manifiesto>
Dado que el método OnReceive () ahora va a estar escuchando para dos tipos de intención de difusión, vale la
pena modificar el código para que la cadena de acción de la intención actual también se muestra en el mensaje
de brindis. Esta cadena se puede obtener a través de una llamada al método getAction () del objeto intención
pasado como argumento al método OnReceive ():

Cadena mensaje = "intención Broadcast detectado"
+ Intent.getAction ();
Toast.makeText (contexto, mensaje,

Toast.LENGTH_LONG) .show ();
}
Pruebe el receptor de volver a instalar el paquete BroadcastReceiver modificado. Al tocar el botón de la

aplicación SendBroadcast ahora debe dar lugar a un nuevo mensaje que contiene la cadena de acción
personalizado:
Intención Broadcast detecta com.ebookfrenzy.sendbroadcast
A continuación, retire el conector USB que está actualmente suministrando energía al dispositivo Android,
momento en el que el receptor debe informar lo siguiente en el mensaje brindis: Broadcast intención detecta
android.intent.action.ACTION_POWER_DISCONNECTED
Resumen
Intentos de difusión son un mecanismo por el cual la intención puede ser emitido para el consumo de varios
componentes en un sistema Android. Las emisiones se detectan mediante el registro de un receptor de
radiodifusión, que, a su vez, está configurado para escuchar las intenciones que responden particulares
cadenas de acciones. En general, los receptores de radiodifusión que permanecen latentes hasta que sea
despertado por el sistema cuando se detecta un intento juego. Intentos de difusión también son utilizados por el
sistema Android para emitir notificaciones de eventos tales como una advertencia de batería baja o la conexión
o desconexión de la alimentación externa al dispositivo.
Además de proporcionar una visión general de los intentos y receptores de radiodifusión, en este capítulo
también ha trabajado a través de un ejemplo de envío de intentos de transmisión y la implementación de un
receptor de radiodifusión para escuchar para ambos intentos de transmisión personalizados y del sistema.
34 Android Threads and Thread Handlers - An Android

Studio Tutorial
El próximo capítulo será el primero de una serie de capítulos destinados a introducir el uso de los Servicios de
Android para realizar tareas de aplicaciones en segundo plano. Es imposible, sin embargo, para entender
completamente los pasos involucrados en la implementación de servicios sin obtener primero una comprensión
básica del concepto de roscar en aplicaciones de Android. Hilos y gestores de hilos son, por lo tanto, el tema de
este capítulo. Una vez que los fundamentos de enhebrado en Android se han cubierto, la teoría se pone en
práctica en la forma de un tutorial proyecto Android Studio mediante roscado.
Una visión general de los Hilos

Los hilos son la piedra angular de cualquier sistema operativo multitarea y pueden ser considerados como mini-
procesos que se ejecutan dentro de un proceso principal, cuyo objetivo es permitir al menos la apariencia de
rutas de ejecución paralelas dentro de las aplicaciones.
El hilo principal de la aplicación

La primera vez que se inicia una aplicación para Android, el sistema de ejecución crea un hilo en el que todos
los componentes de la aplicación se ejecutará de forma predeterminada. Este hilo se conoce generalmente
como el hilo principal. La función principal del hilo principal es manejar la interfaz de usuario en términos de
manejo de eventos y la interacción con vistas en la interfaz de usuario. Cualquier componente adicional que se
inician dentro de la aplicación, por defecto, también se ejecute en el hilo principal.
Cualquier componente dentro de una aplicación que realiza una tarea mucho tiempo usando el hilo principal
hará que toda la aplicación que parecen encerrar hasta que se complete la tarea. Normalmente, esto se
traducirá en el sistema operativo que muestra una "aplicación no responde" advertencia al usuario. Claramente,
esto está lejos de ser el comportamiento deseado para cualquier aplicación. En tal situación, esto puede evitarse
simplemente con el lanzamiento de la tarea a realizar en un hilo separado, permitiendo que el hilo principal para
continuar sin obstáculos con otras tareas.
Los manejadores de hilos

Es evidente que una de las reglas fundamentales del desarrollo de Android no es llevar a cabo las operaciones
que consumen mucho tiempo en el hilo principal de la aplicación.La segunda regla, igualmente importante es
que el código dentro de un subproceso independiente debe nunca, bajo ninguna circunstancia, actualizar
directamente cualquier aspecto de la interfaz de usuario. Cualquier cambio en la interfaz de usuario siempre
deben realizarse desde dentro del hilo principal. La razón de esto es que el conjunto de herramientas de interfaz
de usuario de Android no es seguro para subprocesos. Los intentos de trabajar con código no seguro para
subprocesos desde múltiples hilos típicamente provocar problemas intermitentes y comportamiento de la
aplicación impredecible.
En el caso de que el código que se ejecuta en un hilo necesita interactuar con la interfaz de usuario, debe
hacerlo mediante la sincronización con el hilo principal de la interfaz de usuario. Esto se consigue mediante la
creación de un controlador en el hilo principal, que, a su vez, recibe mensajes desde otro hilo y actualiza la
interfaz de usuario en consecuencia.
Una rosca Ejemplo básico

El resto de este capítulo se trabajará a través de algunos ejemplos sencillos destinados proporcionan una
introducción básica a las roscas. El primer paso será poner de relieve la importancia de la realización de tareas
que consumen mucho tiempo en un hilo separado desde el hilo principal. Comienza, por lo tanto, mediante la
creación de un nuevo proyecto en Android de estudio, entrar ThreadExample en el campo Nombre de la
Siguiente.
actividad en blanco denominada ThreadExampleActivity con una disposición correspondiente llamado
activity_thread_example.
Haga clic en Finalizar para crear el nuevo proyecto
Cargue el archivo activity_thread_example.xml para el proyecto en la herramienta Diseñador. Haga doble clic en
el componente TextView y cambiar el ID para el fin de @ + / Identificación del myTextView. A continuación,
hacer clic y arrastrar el TextView para que se coloca en el centro de la tela de la pantalla.
Añadir una vista Botón para la interfaz de usuario, situado directamente debajo del objeto TextView existente
como se ilustra en la Figura 35-1:
Figura 35-1
Haga doble clic en la vista botón y cambiar el texto que "Pulse Me". Extracto de la cadena en un recurso
denominado button_text. Con todavía seleccionada la vista de botón en el diseño, busque la propiedad onClick
en el panel Propiedades y escriba buttonClick como el nombre del método.
Una vez completado, el contenido del archivo XML debe ser similar a la siguiente lista:

herramientas: context = ". ThreadExampleActivity">
<TextView
android: text = "@ string / hello_world"
android: id = "@ + / Identificación del myTextView" />
<Botón
android: layout_below = "@ + / Identificación del myTextView"
android: onClick = "buttonClick" />
</ RelativeLayout>
A continuación, cargar el archivo ThreadExampleActivity.java en un panel de edición y agregar código para

implementar el método buttonClick () que se llama cuando la Vista de botones es tocado por el usuario. Dado
que el objetivo aquí es demostrar el problema de la realización de tareas largas en el hilo principal, el código
simplemente hacer una pausa durante 20 segundos antes de mostrar un texto diferente en el objeto TextView:
com.ebookfrenzy.threadexample paquete;
public class ThreadExampleActivity extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_thread_example);
}
public void buttonClick (Ver vista)

{
largo endTime = System.currentTimeMillis () + 20 * 1000;
while (System.currentTimeMillis () <endTime) {

sincronizado (este) {
try {
Wait (endTime - System.currentTimeMillis ());
}
}
}
myTextView.setText ("botón presionado");
}
.
.
.
}
Con el código cambia, ejecute la aplicación ya sea en un dispositivo físico o un emulador. Una vez que la
aplicación se está ejecutando, toque el botón, momento en el que aparecerá la solicitud para congelar. Será, por
ejemplo, no ser posible tocar el botón una segunda vez y en algunos casos el sistema operativo, como se
demuestra en la Figura 35-2, reportar la aplicación como no responder:
Figura 35-2
Claramente, cualquier cosa que se va a tomar tiempo para completar dentro del método buttonClick () debe
realizarse dentro de un hilo separado.
Crear un nuevo hilo

Con el fin de crear un nuevo tema, el código que se ejecuta en ese hilo tiene que ser colocado en el método Run
() de una instancia Ejecutable. Un nuevo objeto Thread luego tiene que ser creado, que pasa a través de una
referencia a la instancia Ejecutable al constructor. Por último, el método start () del objeto hilo tiene que ser
llamado para iniciar el hilo conductor. Para llevar a cabo la tarea dentro del método buttonClick (), por lo tanto,
los siguientes cambios deben hacerse:
{
Ejecutable ejecutable = new Ejecutable () {

public void run () {
largo endTime = System.currentTimeMillis ()

+ 20 * 1000;

try {
esperar (endTime -
System.currentTimeMillis ());
} Catch (Exception e) {}
}
}
}
};
MyThread Tema = new Thread (ejecutable);
mythread.start ();
}
Cuando la aplicación se ejecuta ahora, toca el botón hace que el retraso que se realicen en un nuevo hilo
dejando el hilo principal para continuar el manejo de la interfaz de usuario, incluyendo la respuesta a las
pulsaciones de botón adicionales. De hecho, cada vez que se pulsa el botón, se creará un nuevo hilo, lo que
permite que la tarea se lleva a cabo varias veces al mismo tiempo.
Una inspección minuciosa del código actualizado para el método buttonClick () revelará que el código para
actualizar la TextView se ha eliminado. Como se dijo anteriormente, la actualización de un elemento de la
interfaz de usuario desde un subproceso distinto del hilo principal viola una regla clave de desarrollo de
Android. Con el fin de actualizar la interfaz de usuario, por lo tanto, será necesario implementar un controlador
para el hilo.
La implementación de un manejador de Tema

Los manejadores de hilos se implementan en el hilo principal de la aplicación y se utilizan principalmente para
hacer cambios a la interfaz de usuario en respuesta a los mensajes enviados por otros subprocesos que se
ejecutan dentro del proceso de la aplicación.
Los manipuladores son subclases de la clase Handler Android y se puede utilizar ya sea especificando un
Ejecutable para ser ejecutado cuando sea requerido por el hilo, o reemplazando el método de devolución de
llamada handleMessage () dentro de la subclase Handler que se llamará cuando se envían mensajes al
controlador de un hilo.
Para los fines de este ejemplo, un controlador será implementado para actualizar la interfaz de usuario desde
dentro de la rosca prefabricada. Desde dentro de Android de estudio, cargar el archivo
ThreadExampleActivity.java en el editor de Android Studio y modificar el código para agregar una instancia
Handler a la actividad:
android.os.Handler importación;
android.os.Message importación;
Manejador Handler = new Handler () {

@ Override
public void handleMessage (msg Mensaje) {
myTextView.setText ("botón presionado");
}
};
@ Override
setContentView (R.layout.activity_thread_example);
}
.
.
.
}
El código de cambios anteriores han declarado un manejador y aplicado dentro de ese manejador la devolución
de llamada handleMessage () que se llamará cuando el hilo envía al controlador un mensaje. En este caso, el
código simplemente muestra una cadena en el objeto TextView en la interfaz de usuario. Todo lo que queda
ahora es modificar el hilo creado en el método buttonClick () para enviar un mensaje al controlador cuando el
retraso ha completado:

{

largo endTime = System.currentTimeMillis () +

20 * 1000;

try {
esperar (endTime -
} Catch (Exception e) {}
}
}
handler.sendEmptyMessage (0);
}
};

mythread.start ();
Tenga en cuenta que el único cambio que se ha hecho es hacer una llamada al método sendEmptyMessage ()
del manejador. Desde que el manejador no tiene actualmente hace nada con el contenido de los mensajes que
reciben no es necesario para crear y enviar un objeto de mensaje al controlador.
Compilar y ejecutar la aplicación y, una vez que la ejecución, toque el botón. Después de un retraso de 20
segundos, el nuevo texto aparecerá en el objeto TextView en la interfaz de usuario.
Al pasar un mensaje a los Handler

Mientras que el ejemplo anterior provocó una llamada al handleMessage () devolución de llamada manejador,
no se aprovechó del objeto de mensajes para enviar los datos al controlador. En esta fase del tutorial, el ejemplo
se modificó de nuevo para pasar datos entre el hilo y el manejador. En primer lugar, el hilo actualizado en el
método buttonClick () obtendrá la fecha y hora del sistema en formato de cadena y almacenar esa información
en un objeto Bundle. A continuación, se realizó una llamada al método obtainMessage () del objeto controlador
para obtener un objeto de mensaje de la piscina mensaje. Por último, se agregará el haz al objeto de mensaje
antes de ser enviado a través de una llamada al método sendMessage () del objeto handler:
java.text.SimpleDateFormat importación;
java.util.Date importación;
java.util.Locale importación;

.
.
.
{
Msg Mensaje = handler.obtainMessage ();
Haz Bundle = new Bundle ();
SimpleDateFormat dateformat =
nueva SimpleDateFormat ("HH: mm: ss MM / dd / aaaa",
Locale.US);
Cadena DateString =
dateformat.format (new Date ());
bundle.putString ("myKey", DateString);
msg.setData (paquete);
handler.sendMessage (msg);
}
};
mythread.start ();
}
.
.
.
}
A continuación, actualizar el método handleMessage () del manejador para extraer la cadena de fecha y hora del
objeto de lote en el mensaje y lo mostrará en el objeto TextView:
Manejador Handler = new Handler () {

@ Override
Haz Bundle = msg.getData ();
String cadena = bundle.getString ("myKey");
myTextView.setText (cadena);
}
};
Por último, compilar y ejecutar la aplicación y probar que tocar el botón ahora hace que la fecha y hora actuales
a aparecer en el objeto TextView.
Resumen
El objetivo de este capítulo ha sido proporcionar una visión general de roscado dentro de las aplicaciones de
Android. Cuando se inicia una aplicación por primera vez en un proceso, el sistema de ejecución crea un hilo
conductor en el que todos los componentes de la aplicación posteriormente lanzados ejecutan de forma
predeterminada. La función principal del hilo principal es manejar la interfaz de usuario, por lo que las tareas que
consumen tiempo realizados en ese hilo dará la apariencia de que la aplicación se ha bloqueado. Es esencial,
por tanto, que las tareas que podrían tomar tiempo para completar iniciarse en un hilo separado.
Debido a que el conjunto de herramientas de interfaz de usuario de Android no es seguro para subprocesos, no
se deben hacer cambios en la interfaz de usuario en cualquier tema que no sea el hilo principal. Cambios en la
interfaz de usuario se pueden implementar mediante la creación de un controlador en el hilo principal al que los
mensajes pueden ser enviados desde otros no principales hilos.
35 Understanding Android Started and Bound Services
La clase de servicio de Android está diseñado específicamente para permitir a las aplicaciones iniciar y llevar a
cabo las tareas de fondo. A diferencia de los receptores de radiodifusión, que se pretende llevar a cabo una
tarea rápida y luego la salida, los servicios están diseñados para realizar tareas que tardan mucho tiempo en
completarse (como la descarga de un archivo a través de una conexión a Internet o de streaming de música
para el usuario), pero no requieren una interfaz de usuario.
En este capítulo, una visión general de los diferentes tipos de servicios disponibles serán cubiertos, incluyendo
servicios iniciados, servicios ligados y servicios intención. Una vez que estos fundamentos han sido cubiertas,
capítulos posteriores trabajarán a través de una serie de ejemplos basados en Android Estudio de los servicios
en la acción.
Servicios empezados “Started Services”

Servicios iniciados son lanzados por otros componentes de la aplicación (por ejemplo, una actividad o incluso un
receptor de radiodifusión) y potencialmente ejecutar indefinidamente en el fondo hasta que se detiene el
servicio, o se destruye por el sistema de ejecución de Android con el fin de liberar recursos. Un servicio
continuará funcionando si la aplicación que se inició ya no está en primer plano, e incluso en el caso de que el
componente que originalmente inició el servicio se destruye.
Por defecto, un servicio se ejecutará dentro del mismo hilo principal como el proceso de solicitud de la que se
puso en marcha (referido como un servicio local). Es importante, por tanto, que las tareas intensivas de la CPU
pueden realizar en un nuevo hilo dentro del servicio. Instruir a un servicio para funcionar dentro de un proceso
separado (y por lo tanto conocido como un servicio a distancia) requiere un cambio de configuración en el
archivo de manifiesto.
A menos que un servicio está configurado específicamente para ser privada (una vez más a través de una
configuración en el archivo de manifiesto), que el servicio puede ser iniciado por otros componentes en el mismo
dispositivo Android. Esto se logra utilizando el mecanismo de Intención de la misma manera que una actividad
puede iniciar otra como se describe en los capítulos anteriores.
Servicios iniciados se ponen en marcha a través de una llamada al método StartService (), pasando por como
argumento un objeto Intención que identifica el servicio se inicie.Cuando un servicio comenzado ha completado
sus tareas, debe pararse a través de una llamada a stopSelf (). Alternativamente, un servicio en ejecución puede
detenerse por otro componente a través de una llamada al método stopService (), pasando por como argumento
la Intención a juego para que el servicio se detuvo.
Los servicios se les da una alta prioridad por el sistema Android y son típicamente entre los últimos en ser
terminado a fin de liberar recursos.
Servicio de Intención
Como se ha señalado anteriormente, los servicios se ejecutan de forma predeterminada en el mismo hilo
principal como el componente de los que se ponen en marcha. Como tal, las tareas intensivas de la CPU que
deben ser realizadas por el servicio debe tener lugar dentro de un nuevo tema, evitando así afectar al
rendimiento de la aplicación de llamada.
La clase IntentService es una clase de conveniencia (una subclase de la clase de servicio) que configura un
subproceso de trabajo para el manejo de tareas en segundo plano y se ocupa de cada solicitud de una manera
asíncrona. Una vez que el servicio ha atendido todas las solicitudes en cola, simplemente se sale. Todo lo que
se requiere cuando se utiliza la clase IntentService es que se implementará el método onHandleIntent () que
contiene el código que se ejecutará para cada solicitud.
Para los servicios que no requieren procesamiento sincrónico de solicitudes, IntentService es la opción
recomendada. Servicios que requieren manejo sincrónico de las solicitudes serán, sin embargo, la necesidad de
crear una subclase de la clase de servicio y manual de implementar y administrar threading para manejar las
tareas intensivas de la CPU de manera eficiente.
Servicio Bound
Un servicio consolidado es similar a un servicio comenzó con la excepción de que un servicio iniciado por lo
general no devuelve resultados o permitir la interacción con el componente que lo lanzó. Un servicio unido, por
otro lado, permite que el componente de lanzamiento para interactuar con, y recibir los resultados de, el
servicio. A través de la implementación de la comunicación entre procesos (IPC), esta interacción también
puede tener lugar a través de límites de proceso. Una actividad puede, por ejemplo, iniciar un servicio para
manejar la reproducción de audio. La actividad será, con toda probabilidad, incluir una interfaz de usuario que
proporciona controles para el usuario con el propósito de pausa en la reproducción o saltar a la siguiente
pista. Del mismo modo, el servicio será muy probable que tenga que comunicar la información a la actividad de
llamadas para indicar que la pista de audio actual se ha completado y proporcionar detalles de la próxima pista
que está a punto de empezar a jugar.
Un componente (también denominado en este contexto como un cliente) se inicia y se une a un servicio unido a
través de una llamada al método bindService () y de componentes múltiples se puede unir a un servicio de
forma simultánea. Cuando el servicio de la unión ya no es necesario por un cliente, se debe hacer una llamada
al método unbindService (). Cuando el último cliente cota desvincula de un servicio, el servicio se dará por
terminado el sistema de ejecución Android. Es importante tener en cuenta que un servicio ligado también puede
iniciarse a través de llamada a StartService (). Una vez iniciado, los componentes pueden entonces unirse a ella
a través bindService () llama.Cuando se puso en marcha un servicio unido a través de una llamada a
StartService () seguirá funcionando incluso después de que el último cliente desvincula de ella.
Un servicio unido debe incluir una implementación del método onBind () que se llama tanto cuando se crea
inicialmente el servicio y cuando otros clientes posteriormente se unen a la servicio en ejecución. El propósito de
este método es devolver a la unión clientes un objeto de tipo IBinder que contiene la información que necesita el
cliente para comunicarse con el servicio.
En términos de la aplicación de la comunicación entre un cliente y un servicio de encuadernado, la técnica
recomendada depende de si el cliente y el servicio residen en el mismo o diferentes procesos y si es o no el
servicio es privado para el cliente. La comunicación local se puede lograr mediante la extensión de la clase
Binder y devolver un ejemplo del método onBind (). La comunicación entre procesos, por otra parte, requiere la
aplicación Messenger y Handler. Los detalles de estos dos enfoques se tratarán en capítulos posteriores.
La Anatomía de un servicio
Un servicio debe, como ya se ha mencionado, se creará como una subclase de la clase de servicio de Android
(más específicamente android.app.Service) o una sub-clase de la misma (como
android.app.IntentService). Como parte del procedimiento de subclases, uno o más de los siguientes métodos
de devolución de llamada superclase debe ser anulado, dependiendo de la naturaleza exacta del servicio que se
está creando:
 onStartCommand () - Este es el método que se llama cuando el servicio se inicia por otro
componente a través de una llamada al método StartService (). Este método no necesita ser ejecutado por
los servicios consolidados.
 onBind () - Se llama cuando un componente se une al servicio a través de una llamada al método
bindService (). Al implementar un servicio consolidado, este método debe devolver un objeto IBinder
facilitar la comunicación con el cliente. En el caso de los servicios iniciados, este método debe ser
implementado para devolver un valor NULL.
 onCreate () - Concebido como un lugar para llevar a cabo tareas de inicialización, este método se
llama inmediatamente antes de la llamada a cualquiera onStartCommand () o la primera llamada al método
onBind ().
 OnDestroy () - Se llama cuando se está destruyendo el servicio.
 onHandleIntent () - Se aplica sólo a las subclases IntentService. Este método se llama para manejar
el procesamiento por el servicio. Se ejecuta en un hilo separado de la aplicación principal.
Tenga en cuenta que la clase IntentService incluye sus propias implementaciones de los onStartCommand () y
onBind () los métodos de devolución de llamada por lo que estos no necesitan ser implementado en subclases.
Controlar Opciones Reiniciar servicio Destroyed

Se requiere que el método de devolución de llamada onStartCommand () para devolver un valor entero para
definir lo que debería suceder en relación con el servicio en el caso de que se destruyó el sistema de ejecución
Android. Los valores de retorno posibles para estos métodos son los siguientes:
 START_NOT_STICKY - Indica al sistema que el servicio no debe reiniciarse en caso de que se

destruye a menos que existan intenciones pendientes en espera de la entrega.
 START_STICKY - Indica que el servicio debe reiniciarse tan pronto como sea posible después de que
haya sido destruida si la destrucción se produjo después de que el método onStartCommand ()
devuelve. En el caso de que no hay intenciones pendientes están esperando a ser entregado, el método de
devolución de llamada onStartCommand () se llama con un valor NULL intención. La intención está
procesando en el momento en que el servicio fue destruido se descarta.
 START_REDELIVER_INTENT - Indica que, si el servicio fue destruido después de regresar del
método de devolución de llamada onStartCommand (), el servicio debe reiniciarse con la intención actual
entregado de nuevo al método onStartCommand () seguido de cualquier intenciones pendientes.
Declarar un servicio en el archivo de manifiesto

Para que un servicio sea utilizable, lo primero debe ser declarado dentro de un archivo de manifiesto. Esto
implica la incorporación de un elemento <service> configurado adecuadamente en un <application> entrada
existente. Como mínimo, el elemento <service> debe contener una propiedad que se declara el nombre de la
clase de servicio, como se ilustra en el siguiente fragmento de XML:
<Application
<Actividad
android: name = ". TestActivity">
</ Actividad>
<Androide servicio: name = "MiServicio>
</ Service>
</ Application>
</ Manifiesto>
De forma predeterminada, los servicios se declaran como público, en cuanto a que se puede acceder a los
componentes fuera del paquete de solicitud en el que residen. Con el fin de hacer un servicio privado, el
androide: propiedad exportado debe ser declarada como falsa dentro del elemento <service> del archivo de
manifiesto. Por ejemplo:
<Androide servicio: name = "MiServicio"

android: exportado = "false">
</ Service>
Como se discutió previamente, los servicios se ejecutan dentro del mismo proceso como el componente de
llamada por defecto. Con el fin de obligar a un servicio para ejecutar dentro de su propio proceso, añadir un
androide: propiedad de proceso al elemento <service>, declarando un nombre para el proceso con el prefijo dos
puntos (:):
<Androide servicio: name = "MiServicio"

android: exportado = "false"
android: proceso = ": myprocess">
</ Service>
El prefijo de colon indica que el nuevo proceso es privada para la aplicación local. Si el nombre del proceso
comienza con una letra minúscula lugar de dos puntos, sin embargo, el proceso será global y disponible para su
uso por otros componentes.
Por último, utilizando los mismos mecanismos de filtro intención esbozados para las actividades, un servicio
puede también anunciar capacidades a otras aplicaciones que se ejecutan en el dispositivo. Para más detalles
sobre Intención Filtros, consulte el capítulo titulado Una Visión General de Intenciones Android.
Inicio de un servicio que se ejecuta en el inicio del sistema

Dada la naturaleza de fondo de los servicios, no es raro que un servicio necesita ser iniciado cuando un sistema
basado en Android primeras botas arriba. Esto puede lograrse mediante la creación de un receptor de
radiodifusión con un filtro intención configurado para escuchar para el sistema
android.intent.action.BOOT_COMPLETED intención.Cuando se detecta un intento tal, el receptor de
radiodifusión simplemente invocar el servicio necesario y luego regresar. Tenga en cuenta que tal receptor de
radiodifusión tendrá que solicitar el permiso android.permission.RECEIVE_BOOT_COMPLETED para poder
funcionar.
Resumen
Servicios de Android son un poderoso mecanismo que permite a las aplicaciones para realizar tareas en
segundo plano. Un servicio, una vez puesto en marcha, continuará funcionando independientemente de si la
aplicación de llamada ya no es la tarea de primer plano y, incluso en el caso de que el componente que inicia el
servicio se destruye.
Los servicios son una subclase de la clase de servicio de Android y entran en la categoría de cualquiera de los
servicios iniciadas o servicios consolidados. Servicios iniciados correr hasta que se detienen o se destruyen y no
proporcionan por sí un mecanismo de interacción o intercambio de datos con otros componentes. Servicios
Bound, por otro lado, proporcionan una interfaz de comunicación con otros componentes del cliente y, en
general, corren hasta que el último cliente se suelta del servicio.
De forma predeterminada, los servicios se ejecutan localmente en el mismo proceso y el hilo principal como la
aplicación de llamada. Un nuevo hilo debe, por lo tanto, se creará dentro del servicio con el fin de manejar las
tareas intensivas de la CPU. Los servicios remotos pueden comenzarse después de un proceso separado al
hacer un cambio de configuración menor a la correspondiente <service> entrada en el archivo de manifiesto de
aplicación.
La clase IntentService (en sí misma una subclase de la clase de servicio de Android) proporciona un mecanismo
conveniente para el manejo de solicitudes de servicios asíncronos dentro de un subproceso de trabajo
independiente.
36 Implementing an Android Started Service in Android

Studio
En el capítulo anterior cubierto una considerable cantidad de información relativa a los servicios de Android y, en
este punto, el concepto de servicios puede parecer un poco abrumador. Con el fin de reforzar la información en
el capítulo anterior, este capítulo va a funcionar a través de un tutorial Android Estudio destinado a introducir
gradualmente los conceptos de implementación del servicio iniciado.
Dentro de este capítulo, una aplicación de ejemplo se crea y se utiliza como base para la implementación de un
servicio de Android. En el primer caso, el servicio se creará mediante la clase IntentService. Este ejemplo se
extenderá posteriormente a demostrar el uso de la clase de servicio. Por último, se llevarán a cabo los pasos
necesarios para la realización de tareas en un hilo separado cuando se utiliza la clase de servicio. Tener
servicios iniciados tratados en este capítulo, el siguiente capítulo, titulado Bound Servicios de Ejecución locales
en Android Estudio , se centrará en la implementación de servicios con destino y la comunicación cliente-
servicio.

Lanzamiento Android Studio y siga los pasos habituales para crear un nuevo proyecto, entrando
ServiceExample en el campo Nombre de la aplicación y ebookfrenzy.com como el ajuste de dominio de la
empresa antes de hacer clic en el botón Siguiente.
actividad en blanco denominada ServiceExampleActivity con una disposición correspondiente llamado
activity_service_example.
Creación de la clase de servicio

Antes de escribir ningún código, el primer paso es agregar una nueva clase al proyecto para contener el
servicio. El primer tipo de servicio que se ha demostrado en este tutorial es que basarse en la clase
IntentService. Como se ha señalado en el capítulo anterior ( Understanding Android Iniciado y Servicios Bound ),
el propósito de la clase IntentService es proporcionar al desarrollador con un mecanismo conveniente para la
creación de servicios que realizan tareas de forma asincrónica en un subproceso independiente de la aplicación
de llamada.
Agregar una nueva clase al proyecto haciendo clic derecho sobre el nombre del paquete
com.ebookfrenzy.servicexample situado bajo ServiceExample -> aplicación -> src -> principal - el> Java en la
ventana de herramientas del proyecto y seleccionando Nueva opción -> Java Class menú . En el cuadro de
diálogo Crear nueva clase resultante, el nombre del nuevo MyIntentService clase. Por último, haga clic en el
botón Aceptar para crear la nueva clase.
Revise el nuevo archivo MyIntentService.java en el editor de Android estudio donde se leerá como sigue:
com.ebookfrenzy.serviceexample paquete;
/ **
* Creado por <nombre> el <fecha>.
* /
public class MyIntentService {
}
La clase tiene que ser modificado de manera que las subclases de la clase IntentService. Cuando subclases la
clase IntentService, hay dos reglas que se deben seguir. En primer lugar, un constructor de la clase debe
implementar el cual llama al constructor de la superclase, que pasa por el nombre de la clase del servicio. En
segundo lugar, la clase debe reemplazar el método onHandleIntent (). Modifique el código en el archivo
MyIntentService.java, por lo tanto, para que se lea de la siguiente manera:
android.app.IntentService importación;
public class MyIntentService extiende IntentService {
@ Override
protegida onHandleIntent void (arg0 Intención) {
MyIntentService público () {
super ("MyIntentService");
}
}
Todo lo que queda en este punto es implementar un código dentro del método onHandleIntent () para que el
servicio realmente hace algo cuando se invoca. Normalmente esto implicaría la realización de una tarea que
toma algún tiempo para completar, como la descarga de un archivo de gran tamaño o la reproducción de
audio. Para los fines de este ejemplo, sin embargo, el manejador de salida simplemente un mensaje al panel
Android Estudio LogCat:
android.app.IntentService importación;
public class MyIntentService extiende IntentService {
estática TAG final String privado =

"Com.ebookfrenzy.serviceexample";
@ Override
protegida onHandleIntent void (arg0 Intención) {
Log.i (TAG, "Servicio Intención comenzó");
}
MyIntentService público () {
super ("MyIntentService");
}
}
Añadiendo el Servicio para el archivo de manifiesto

Antes de que un servicio puede ser invocada, en primer lugar hay que añadir al archivo de manifiesto de la
aplicación a la que pertenece. Como mínimo, esto implica la adición de un elemento <service> junto con el
nombre de la clase del servicio.
Haga doble clic en el archivo AndroidManifest.xml para el proyecto actual para cargarlo en el editor y modificar
el código XML para añadir el elemento de servicio como se muestra en el siguiente listado:

paquete = "com.ebookfrenzy.serviceexample">
<Application
<Actividad
android: ". ServiceExampleActivity" name =

</ Actividad>
<Androide servicio: ". MyIntentService" name = />
</ Application>
</ Manifiesto>
Inicio del servicio

Ahora que el servicio ha sido implementado y declarada en el archivo de manifiesto, el siguiente paso es
agregar código para iniciar el servicio cuando se inicia la aplicación.Como suele ser el caso, el lugar ideal para
tal código es el método de devolución de llamada onCreate () de la clase de actividad (que, en este caso, se
puede encontrar en el archivo ServiceExampleActivity.java). Localice y cargue el archivo en el editor y modificar
el método onCreate () para agregar el código para iniciar el servicio:
public class ServiceExampleActivity extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_service_example);
Intención Intención = new Intent (esto, MyIntentService.class);
StartService (intención);
}
.
.
.
}
Todo lo que el código añadido tiene que hacer es crear un nuevo objeto de Intención cebado con el nombre de
clase de servicio para comenzar y luego utilizarlo como argumento para el método StartService ().
Probando el Ejemplo IntentService

El servicio basado ejemplo IntentService ya está completo y listo para ser probado. Dado que el mensaje
mostrado por el servicio aparecerá en el panel LogCat, es importante que este está configurado en el entorno
Android Studio.
Comienza mostrando la ventana de herramientas Android utilizando el botón de menú de herramientas situada
en la esquina izquierda de la barra de estado o la Alt-6 atajo de teclado. Dentro de la ventana de la herramienta,
asegúrese de que los dispositivos | pestaña Logcat se selecciona antes de acceder al menú de la esquina
superior derecha del panel (que probablemente leerá Actualmente Sin filtros). Desde este menú, seleccione la
opción de menú Configuración Editar filtro.
En el Crear nuevo Logcat Filtra nombre diálogo ServiceExample filtro y, en el campo por Tag Log (regex),
introduzca el valor TAG declarado en ServiceExampleActivity.java (en el ejemplo de código anterior era
com.ebookfrenzy.serviceexample pero es posible que haya cambiado esto para reflejar la URL de su empresa).
Al completar los cambios, haga clic en el botón Aceptar para crear el filtro y cerrar el diálogo. En vez de
enumerar Sin filtros, el filtro recién creado ahora debe ser seleccionado en la ventana de herramientas
Android. Con el filtro configurado, ejecutar la aplicación en un dispositivo o emulador AVD sesión física y tenga
en cuenta que el "Servicio Intención Started" aparece en el panel LogCat (tenga en cuenta que puede ser
necesario cambiar la configuración de nuevo a ServiceExample después de la aplicación de menú filtro ha
puesto en marcha):
5 al 20 09: 38: 50,953 10961 a 10996 / com.ebookfrenzy.serviceexample I /
com.example.serviceexample: Servicio Intención empezó
El servicio había recibido el encargo de una actividad a largo plazo, el servicio hubiera seguido corriendo en el
fondo en un hilo separado hasta que se completó la tarea, lo que permite que la aplicación continúe funcionando
y respondiendo al usuario. Dado que todo nuestro servicio hizo fue ingrese un mensaje, se habrá dejado
simplemente al finalizar.
Utilizando la clase de servicio

Mientras que la clase IntentService permite un servicio para ser implementado con la codificación mínima, hay
situaciones en las que se requieren la flexibilidad y la naturaleza sincrónica de la clase de servicio. Como se
hará evidente en esta sección, esto implica un cierto trabajo de programación adicional para implementar.
Con el fin de evitar la introducción de demasiados conceptos a la vez, y como demostración de los riesgos
inherentes a la realización de tareas de servicio que requieren mucho tiempo en el mismo hilo como la
aplicación de llamada, el servicio de ejemplo creado aquí no se ejecutará la tarea de servicio en un nuevo hilo ,
en lugar de confiar en el hilo principal de la aplicación. Creación y gestión de un nuevo hilo dentro de un servicio
se tratarán en la próxima fase del tutorial.
Cómo crear un nuevo servicio

Para los fines de este ejemplo, se añadirá una nueva clase al proyecto que subclase de la clase de
servicio. Haga clic derecho, por lo tanto, en el nombre del paquete que aparece bajo ServiceExample ->
aplicación -> src -> principal -> Java en la ventana de herramientas de proyectos y seleccione Nuevo -> Servicio
-> opción de menú Servicio.Crear una nueva clase llamada MiServicio tanto con las opciones exportados y
habilitados seleccionados.
El requisito mínimo para crear un servicio operativo es poner en práctica el método de devolución de llamada
onStartCommand () que se llamará cuando el servicio se está iniciando. Además, el método onBind () debe
devolver un valor nulo para indicar al sistema de Android que este no es un servicio unido. Para los fines de este
ejemplo, el método onStartCommand () se bucle tres veces la realización de una espera de 10 segundos en
cada bucle. Para mayor abundamiento, las versiones de código auxiliar del onCreate () y OnDestroy () métodos
también se llevarán a cabo en el nuevo archivo MyService.java de la siguiente manera:
android.app.Service importación;
android.os.IBinder importación;
public class MiServicio extiende Servicio {
MiServicio público () {
}
estática TAG final String privado =

"Com.ebookfrenzy.serviceexample";
@ Override
public void onCreate () {
Log.i (TAG, "Servicio onCreate");
}
@ Override
public int onStartCommand (intención Intención, int banderas, int startID) {
Log.i (TAG, "Servicio onStartCommand");
for (int i = 0; i <3; i ++) {

10 * 1000;
try {
Wait (endTime - System.currentTimeMillis ());
}
}
}
Log.i (TAG, "Servicio de funcionamiento");
}
volver Service.START_STICKY;
}
@ Override
pública IBinder onBind (arg0 Intención) {
Log.i (TAG, "Servicio onBind");
devolver null;
}
@ Override
pública OnDestroy void () {
Log.i (TAG, "OnDestroy Servicio");
}
}
Con el servicio implementado, cargue el archivo AndroidManifest.xml en el editor y verifique que Android Studio
ha añadido una entrada apropiada para el nuevo servicio, que queda redactado como sigue:
<Servicio
android: ". MiServicio" name =
</ Service>
La modificación de la interfaz de usuario

Como se hará evidente cuando se ejecuta la aplicación, en su defecto para crear un nuevo hilo para el servicio
para realizar tareas crea un problema de usabilidad grave. Con el fin de poder apreciar plenamente la magnitud
de este problema, que va a ser necesario añadir una vista Button a la interfaz de usuario de la actividad
ServiceExampleActivity y configurarlo para llamar a un método cuando "clic" por el usuario.
Localice y cargue el archivo activity_service_example.xml en la ventana de la herramienta de proyecto
(aplicación -> src -> principal -> res -> diseño -> activity_service_example.xml). Elimine el TextView y añadir una
vista Button al diseño. Haga doble clic en el nuevo botón y cambiar el texto para leer "Iniciar servicio". Utilice el
menú del icono de la luz de bulbo para extraer la cadena en un recurso denominado button_text.
Con aún seleccionado el nuevo botón, busque la propiedad onClick en el panel Propiedades y asignarle un
método llamado buttonClick. Al finalizar, el XML para el diseño de la interfaz de usuario debe ser similar a la
siguiente lista:

"com.ebookfrenzy.serviceexample.serviceexample.ServiceExampleActivity">
<Botón
android: onClick = "buttonClick" />
</ RelativeLayout>
A continuación, edite el archivo ServiceExampleActivity.java añadir el método buttonClick () y eliminar el código

del método onCreate () que se ha añadido previamente para lanzar el servicio MyIntentService:
public class ServiceExampleActivity extiende ActionBarActivity {
@ Override
setContentView (R.layout.activity_service_example);
}

{
Intención Intención = new Intent (esto, MyService.class);
StartService (intención);
}
}
Todo lo que el método buttonClick () hace es crear un objeto intención para el nuevo servicio e inicie
funcionando.
Ejecutar la aplicación y, una vez cargado, toque el botón Iniciar servicio. Dentro de la ventana LogCat (utilizando
el filtro ServiceExample creado previamente) los mensajes de registro aparecerá indicando que se ha llamado el
método onCreate () y que el bucle en el onStartCommand () método se está ejecutando.
Antes de que aparezca el mensaje de bucle final, tratar de tocar el botón Iniciar servicio por segunda vez. Tenga
en cuenta que el botón no responde. Después de unos 20 segundos, el sistema puede mostrar un cuadro de
diálogo de advertencia con el mensaje "ServiceExample no responde". La razón de esto es que el hilo principal
de la aplicación se encuentra detenido por el servicio mientras se realiza la tarea de bucle. Esto no sólo impide
la aplicación de responder al usuario, sino también para el sistema, que eventualmente supone que la aplicación
se ha bloqueado de alguna manera.
Claramente, el código para el servicio necesita ser modificado para realizar tareas en un hilo separado desde el
hilo principal.
Crear un nuevo hilo para tareas de servicio

Como se indica en Temas Android y gestores de hilos - Un Estudio Tutorial Android , la primera vez que se inicia
una aplicación para Android, el sistema de ejecución crea un hilo en el que todos los componentes de la
aplicación se ejecutará de forma predeterminada. Este hilo se conoce generalmente como el hilo principal. La
función principal del hilo principal es manejar la interfaz de usuario en términos de manejo de eventos y la
interacción con vistas en la interfaz de usuario. Cualquier componente adicional que se inician dentro de la
aplicación, por defecto, también se ejecute en el hilo principal.
Como se ha demostrado en el apartado anterior, cualquier componente que lleva a cabo una operación que
consume tiempo en el hilo principal hará que la aplicación deje de responder hasta que la tarea se ha
completado. No es de extrañar, por tanto, que Android ofrece una API que permite a las aplicaciones crean y
utilizan subprocesos adicionales.Cualquier tareas realizadas en un hilo separado desde el hilo principal se
llevaron a cabo esencialmente en el fondo. Estos hilos se refieren típicamente como hilos de fondo o de los
trabajadores.
Una solución muy simple a este problema consiste en la realización de la misión de servicio en un nuevo hilo. El
método siguiente onStartCommand () del archivo MyService.java, por ejemplo, se ha modificado para iniciar la
tarea en un nuevo hilo con el más básico de los ejemplos de manipulación de hilo:
@ Override
public int onStartCommand (intención Intención, int banderas, int startID) {
Log.i (TAG, "Servicio onStartCommand" + startID);
última int currentId = startID;
R = new Ejecutable Ejecutable () {

for (int i = 0; i <3; i ++)

{
10 * 1000;

try {
esperar (endTime -
}
}
}
Log.i (TAG, "Servicio de funcionamiento" + currentId);
}
stopSelf ();
}
};
T = new Thread Thread (r);

t.Start ();
volver Service.START_STICKY;
}
Cuando la aplicación es ahora dirigido, debe ser posible tocar el botón Inicio Servicio varias veces. Cada vez
que un nuevo hilo se crea el servicio para procesar la tarea. La salida LogCat ahora también incluir un número
de referencia a la startID de cada solicitud de servicio.
Con el servicio de ahora el manejo de solicitudes fuera del hilo principal, la aplicación sigue siendo sensible a la
vez que el usuario y el sistema Android.
Resumen
En este capítulo se ha trabajado a través de un ejemplo de implementación de un servicio de Android empezado
a utilizar las clases IntentService y Servicio. El ejemplo también demuestra el uso de hilos dentro de un servicio
para evitar que el hilo principal de la aplicación que no responde.
37 Implementing Local Bound Services in Android Studio
Como se describe en detalle en los capítulos anteriores, los servicios con destino, a diferencia de los servicios
iniciados, proporcionan un mecanismo para implementar la comunicación entre un servicio de Android y uno o
más componentes de cliente. El objetivo de este capítulo es el de construir sobre el panorama general de los
servicios con destino previstos en Comprensión Android Iniciado y Bound Servicios antes de embarcarse en un
ejemplo de implementación de un servicio consolidado local en acción.
Comprensión Bound Servicios ‘Understanding Bound Services’

En común con los servicios iniciados, los servicios con destino se proporcionan para permitir que las
aplicaciones para realizar tareas en el fondo. A diferencia de servicios iniciados, sin embargo, múltiples
componentes de cliente se pueden unir a un servicio de atado y, una vez unido, interactuar con dicho servicio
utilizando una variedad de mecanismos diferentes. Servicios Bound se crean como subclases de la clase de
servicio de Android y deben, como mínimo, aplicar el método onBind (). Los componentes de cliente se unen a
un servicio a través de una llamada al método bindService (). La primera solicitud de enlace a un servicio
consolidado resultará en una llamada a ese método onBind de servicio () (solicitud de enlace posterior no
desencadenar una onBind () llamada). Los clientes que deseen unirse a un servicio también deben implementar
una subclase ServiceConnection contiene onServiceConnected () y onServiceDisconnected () métodos que se
llamará una vez que la conexión cliente-servidor se ha establecido o desconectado, respectivamente. En el caso
del método de onServiceConnected (), esta se pasa un objeto IBinder que contiene la información necesaria por
el cliente para interactuar con el servicio.
Bound Servicio Opciones de interacción

Existen dos mecanismos recomendados para la implementación de la interacción entre los componentes de
cliente y un servicio de encuadernado. En el caso de que el servicio límite es local y privado a la misma
aplicación que el componente de cliente (en otras palabras, se ejecuta en el mismo proceso y no está disponible
para componentes en otras aplicaciones), el mecanismo recomendado es crear una subclase de la clase Binder
y extenderlo para proporcionar una interfaz para el servicio. Una instancia de este objeto Carpeta se devuelve
mediante el método onBind () y posteriormente utilizado por el componente de cliente para acceder
directamente a los métodos y datos contenidos en el servicio.
En situaciones donde el servicio unido no es local a la aplicación (en otras palabras, se está ejecutando en un
proceso diferente de la componente de cliente), la interacción se logra mejor usando una aplicación mensajero /
Handler.
En el resto de este capítulo, un ejemplo se crea con el objetivo de demostrar los pasos implicados en la
creación, el inicio y la interacción con un servicio ligado privado local.
Un servicio Ejemplo Bound Android Estudio Local

La aplicación de ejemplo creada en el resto de este capítulo consistirá en una sola actividad y un servicio de
encuadernado. El objetivo del servicio unido es obtener la hora actual del sistema y regresar esa información a
la actividad en la que se mostrará al usuario. El servicio con destino será local y privado a la misma aplicación
que la actividad.
Lanzamiento Android Studio y siga los pasos habituales para crear un nuevo proyecto, que entra en LocalBound
en el campo Nombre de la aplicación y ebookfrenzy.com como el dominio de la empresa establecer antes de
hacer clic en el botón Siguiente.
actividad en blanco denominada LocalBoundActivity con una disposición correspondiente llamado
activity_local_bound.
Una vez que el proyecto ha sido creado, el siguiente paso es agregar una nueva clase de actuar como el
servicio de encuadernado.
Agregar un servicio Bound con el Proyecto

Para agregar una nueva clase al proyecto, haga clic en el nombre del paquete (que se encuentra bajo
LocalBound -> aplicación -> src -> principal -> Java -> com.ebookfrenzy.localbound) dentro de la ventana de
herramientas de proyectos y seleccione Nuevo - > Servicio -> opción de menú Servicio. Especifique
BoundService como el nombre de la clase y asegurarse de que tanto las opciones exportados y habilitados son
seleccionados antes de hacer clic en Finalizar para crear la clase. Por defecto Android Estudio cargará el
archivo BoundService.java en el editor, donde se leerá como sigue:
com.ebookfrenzy.localbound paquete;
public class BoundService extiende Servicio {

BoundService público () {
}
@ Override
pública IBinder onBind (intención Intención) {
// TODO: Devuelva el canal de comunicación con el servicio.
}
}
La implementación de la Carpeta
Como se ha indicado anteriormente, los servicios ligados locales pueden comunicarse con los clientes
consolidados por pasar un objeto Carpeta configurado apropiadamente para el cliente. Esto se logra mediante la
creación de una subclase carpeta dentro de la clase de servicio consolidado y que se extiende por la adición de
uno o más nuevos métodos que pueden ser llamados por el cliente. En la mayoría de los casos, esto implica
simplemente la aplicación de un método que devuelve una referencia a la instancia de servicio unido. Con
referencia a la presente instancia, el cliente puede entonces acceder a los datos y los métodos de llamada
dentro del servicio ligada directamente.
A los efectos de este ejemplo, por lo tanto, se necesitan algunos cambios para la clase de plantilla
BoundService creado en la sección anterior. En el primer caso, una subclase Carpeta necesita ser
declarado. Esta clase contendrá un único método denominado a getService () que devuelva una referencia a la
instancia del objeto de servicio actual (representada por la palabra clave this). Con estos requisitos en mente,
edite el archivo BoundService.java y modificarlo de la siguiente manera:
android.os.Binder importación;
última IBinder MyBinder = new MyLocalBinder privado ();
}
@ Override
}
public class MyLocalBinder extiende Carpeta {

BoundService a getService () {
volver BoundService.this;
}
}
}
Después de haber realizado los cambios a la clase, vale la pena tomar un momento para recapitular los pasos
realizados aquí. En primer lugar, se declaró una nueva subclase de Carpeta (llamado MyLocalBinder). Esta
clase contiene un único método para el único propósito de devolver una referencia a la instancia actual de la
clase BoundService. Se crea una nueva instancia de la clase MyLocalBinder y asignado a la referencia
MyBinder IBinder (desde la carpeta es una subclase de IBinder no hay coincidencia de tipos en esta tarea).
A continuación, el onBind () método necesita ser modificado para devolver una referencia al objeto MyBinder y
un nuevo método público implementado para devolver la hora actual cuando llamado por cualquier cliente que
se unen al servicio de:
java.text.SimpleDateFormat importación;
java.util.Date importación;
java.util.Locale importación;
android.os.Binder importación;
última IBinder MyBinder = new MyLocalBinder privado ();
}
@ Override
volver MyBinder;
}
public String GetCurrentTime () {

SimpleDateFormat dateformat =
nueva SimpleDateFormat ("HH: mm: ss MM / dd / aaaa",
Locale.US);
retorno (dateformat.format (new Date ()));
}
public class MyLocalBinder extiende Carpeta {

BoundService a getService () {
volver BoundService.this;
}
}
}
En este punto, el servicio unido es completa y está listo para ser agregado al archivo de manifiesto de
proyecto. Localice y haga doble clic en el archivo AndroidManifest.xml para el proyecto LocalBound en la
ventana de herramientas del proyecto y, una vez cargado en el Editor de manifiesto, compruebe que Android
estudio ya ha añadido un elemento <service> entrada para el servicio de la siguiente manera:

paquete = "com.ebookfrenzy.localbound.localbound">
<Application
<Actividad
android: name = ". LocalBoundActivity"

</ Actividad>
<Servicio
android: name = ". BoundService"
</ Service>
</ Application>
</ Manifiesto>
La siguiente fase es poner en práctica el código necesario dentro de la actividad de unirse al servicio y llamar al
método GetCurrentTime ().
La unión del Cliente para el Servicio

A los efectos de este tutorial, el cliente es la instancia LocalBoundActivity de la aplicación en ejecución. Como se
señaló anteriormente, a fin de obligar con éxito a un servicio y recibir el objeto IBinder devuelto por el método del
servicio onBind (), es necesario para crear una subclase ServiceConnection y aplicar onServiceConnected () y
onServiceDisconnected () los métodos de devolución de llamada. Edite el archivo LocalBoundActivity.java y
modificarlo de la siguiente manera:
android.content.ComponentName importación;
android.content.ServiceConnection importación;
com.ebookfrenzy.localbound.BoundService.MyLocalBinder importación;
public class LocalBoundActivity extiende ActionBarActivity {
BoundService myService;
boolean isBound = false;
@ Override
setContentView (R.layout.activity_local_bound);
}
myConnection ServiceConnection privado = new ServiceConnection ()

{
public void onServiceConnected (ComponentName className,

IBinder servicio) {
MyLocalBinder aglutinante = servicio (MyLocalBinder);
myService = binder.getService ();
isBound = true;
}
public void onServiceDisconnected (arg0 ComponentName) {

isBound = false;
}
};
}
El método onServiceConnected () será llamada cuando el cliente se une con éxito al servicio. El método se pasa
como argumento el objeto IBinder devuelto por el método onBind () del servicio. Este argumento se echa a un
objeto de tipo MyLocalBinder y luego se llama al método a getService () del objeto aglutinante para obtener una
referencia a la instancia de servicio, que, a su vez, se asigna a myService. Una bandera booleana se utiliza para
indicar que la conexión se ha establecido con éxito.
El método onServiceDisconnected () se llama cuando la conexión termina y simplemente establece el indicador
booleano false.
Después de haber establecido la conexión, el siguiente paso es para modificar la actividad para unirse al
servicio. Esto implica la creación de una intención y una llamada al método bindService (), que se puede realizar
en el método onCreate () de la actividad:
@ Override
setContentView (R.layout.activity_local_bound);
Intención Intención = new Intent (esto, BoundService.class);
bindService (intención, myConnection, Context.BIND_AUTO_CREATE);
}
Completando el Ejemplo
Todo lo que queda es poner en práctica un mecanismo para llamar al método GetCurrentTime () y mostrar el
resultado al usuario. Como ya es costumbre, Android Estudio habrá creado un archivo activity_local_bound.xml
plantilla para la actividad que contiene sólo un TextView. Cargar este archivo en la herramienta Diseñador
utilizando el modo de diseño, haga doble clic en el componente TextView y cambiar el ID de @ + / Identificación
del myTextView. Mueva el TextView al centro del lienzo la pantalla, añada una vista botón debajo de la TextView
y cambiar el texto en el botón para leer "Show Time", extraer el texto a un recurso de cadena denominada
button_string. Al término de estos cambios, el diseño debe ser similar a la ilustrada en la Figura 38-1:
Figura 38-1
A continuación, cambiar Diseñador en modo texto y modificar el elemento de botón para declarar una propiedad
onClick configurado para llamar a un método llamado showTime:

herramientas: context = ". LocalBoundActivity">
<TextView
android: text = "@ string / hello_world"
android: id = "@ + / Identificación del myTextView" />
<Botón
android: layout_below = "@ + / Identificación del myTextView"
android: onClick = "Showtime"
</ RelativeLayout>
Finalmente, editar el código en el archivo LocalBoundActivity.java para implementar el método showTime

(). Este método simplemente llama al método GetCurrentTime () del servicio (que, gracias al método
onServiceConnected (), ya está disponible desde dentro de la actividad a través de la referencia myService) y
asigna la cadena resultante de la TextView:
com.ebookfrenzy.localbound.BoundService.MyLocalBinder importación;
public class LocalBoundActivity extiende ActionBarActivity {
BoundService myService;
boolean isBound = false;
public void showTime (Ver vista)

{
Cadena horaActual = myService.getCurrentTime ();
myTextView.setText (horaActual);
}
.
.
.
}
Con el código cambia completa, realice una prueba de funcionamiento de la aplicación. Una vez visible, toque el
botón y tenga en cuenta que la vista cambia el texto para mostrar la fecha y la hora actual. El ejemplo se ha
iniciado satisfactoriamente y con destino a un servicio y, a continuación llamado un método de ese servicio para
causar una tarea a realizar y resultados devueltos a la actividad.
Resumen
Cuando un servicio con destino es local y privado a una aplicación, los componentes dentro de esa aplicación
puede interactuar con el servicio sin la necesidad de recurrir a la comunicación entre procesos (IPC). En
términos generales, el método del servicio onBind () devuelve un objeto IBinder que contiene una referencia a la
instancia del servicio en ejecución. El componente de cliente implementa una subclase ServiceConnection
contiene métodos de devolución de llamada que se llaman cuando el servicio está conectado y desconectado
El primer método se pasa el objeto IBinder devuelto por el método onBind () que permite métodos públicos en el
servicio a ser llamados.
Después de haber cubierto la implementación de servicios con destino local, el siguiente capítulo se centrará en
el uso de IPC para interactuar con los servicios con destino a distancia.
38 Android Servicios Bound remoto - Un Estudio Android
Tutorial
En esto, el capítulo final dedicado a servicios de Android, una aplicación de ejemplo se desarrollará para
demostrar el uso de una configuración de controlador de mensajero y para facilitar la interacción entre un cliente
y un servicio unido a distancia.
iente Comunicación del servicio remoto

Como se ha señalado en el capítulo anterior, la interacción entre un cliente y un servicio local puede
implementarse mediante la devolución al cliente un objeto IBinder contiene una referencia al objeto de
servicio. En el caso de servicios remotos, sin embargo, este enfoque no funciona debido a que el servicio
remoto se ejecuta en un proceso diferente y, como tal, no se puede alcanzar directamente desde el cliente.
En el caso de los servicios a distancia, una configuración de Messenger y Handler debe ser creado que permite
que los mensajes que se pasan a través de límites de proceso entre el cliente y el servicio.
En concreto, el servicio crea una instancia de Handler que será llamada cuando se recibe un mensaje del
cliente. En términos de la inicialización, es el trabajo del manejador para crear un objeto de Messenger que, a su
vez, crea un objeto IBinder que se devuelve al cliente en el método onBind (). Este objeto IBinder es utilizado
por el cliente para crear una instancia del objeto Messenger y, posteriormente, para enviar mensajes al
controlador de servicio. Cada vez que un mensaje es enviado por el cliente, se llama al método handleMessage
() del controlador, que pasa a través del objeto de mensaje.
El ejemplo sencillo creado en este capítulo consistirá en una actividad y un servicio consolidado que se ejecutan
en procesos separados. El mecanismo del mensajero / Handler se usará para enviar una cadena al servicio, lo
cual se mostrará esa cadena en un mensaje Toast.

Lanzamiento Android Studio y siga los pasos para crear un nuevo proyecto, entrando RemoteBound en el
campo Nombre de la aplicación y ebookfrenzy.com como el ajuste de dominio de la empresa antes de hacer clic
en el botón Siguiente.
actividad en blanco denominada RemoteBoundActivity con una disposición correspondiente llamado
activity_remote_bound.

Busque el archivo activity_remote_bound.xml en la ventana de herramientas del proyecto y haga doble clic en él
para cargarlo en la herramienta Diseñador. Con la herramienta de diseño en modo Diseño, elimine la instancia
predeterminada de Vista de Texto y arrastre una caída de un widget de botón de la paleta de manera que se
coloca en el centro de la distribución. Haga doble click en el botón y cambiar la propiedad de texto que diga
"Enviar mensaje". Extraer la cadena mediante el menú bombilla a un nuevo recurso de cadena denominada
button_text.
A continuación, encienda Designer para el modo de texto y modifique el elemento Button para declarar una
propiedad onClick:

"com.ebookfrenzy.remotebound.remotebound.RemoteBoundActivity">
<Botón
android: onClick = "sendMessage" />
</ RelativeLayout>
Implementación del Servicio Bound remoto

Con el fin de implementar el servicio con destino a distancia para este ejemplo, agregar una nueva clase al
proyecto haciendo clic derecho sobre el nombre del paquete (que se encuentra bajo RemoteBound -> aplicación
-> src -> principal -> java) dentro de la ventana de herramientas de proyectos y seleccione Nuevo el -> Servicio
-> opción de menú Servicio. Especifique RemoteService como el nombre de la clase y asegurarse de que tanto
las opciones exportados y habilitados son seleccionados antes de hacer clic en Finalizar para crear la clase.
El siguiente paso es la implementación de la clase controlador para el nuevo servicio. Esto se logra mediante la
ampliación de la clase Handler y aplicar el método handleMessage (). Este método se llama cuando se recibe un
mensaje desde el cliente. Se pasa como argumento un objeto de mensaje que contiene los datos que el cliente
necesita para pasar al servicio. En este caso, esto será un objeto de paquete que contiene una cadena que se
mostrará al usuario. La clase modificada en el archivo RemoteService.java debe decir lo siguiente una vez que
esta se ha implementado:
com.ebookfrenzy.remotebound paquete;
android.os.Messenger importación;
public class RemoteService extiende Servicio {
RemoteService público () {
}
clase IncomingHandler extiende Handler {

@ Override
Datos Bundle = msg.getData ();

Cadena dataString = data.getString ("MyString");
Toast.makeText (getApplicationContext (),
dataString, Toast.LENGTH_SHORT) .show ();
}
}
@ Override
}
}
Con el controlador implementado, la tarea que queda en términos del código de servicio es modificar el método
onBind () de manera que devuelve un objeto IBinder que contiene un objeto mensajero que, a su vez, contiene
una referencia al controlador de:
Mensajero final myMessenger = nuevo Messenger (nuevo IncomingHandler ());
@ Override
volver myMessenger.getBinder ();
}
La primera línea del fragmento de código anterior crea una nueva instancia de nuestra clase de controlador y se
lo pasa a través de al constructor de un nuevo objeto Messenger. Dentro del método onBind (), el método
getBinder () del objeto mensajero se llama a regresar objeto IBinder del mensajero.
Configuración de un servicio remoto en el archivo de manifiesto

Con el fin de describir la comunicación entre un cliente y el servicio a distancia con precisión, será necesario
configurar el servicio para ejecutar en un proceso separado del resto de la aplicación. Esto se logra mediante la
adición de un androide: propiedad proceso dentro de la <servicio> para el servicio en el archivo de
manifiesto. Con el fin de lanzar un servicio remoto, también es necesario proporcionar un filtro de intención para
el servicio. Para implementar estos cambios, modificar el archivo AndroidManifest.xml añadir las entradas
necesarias:

paquete = "com.ebookfrenzy.remotebound">
<Application
<Actividad
android: name = ". RemoteBoundActivity"

</ Actividad>
<Servicio
android: name = ". RemoteService"
android: exportado = "true"
android: proceso = ": my_process">
<Acción android: name = "com.example.remoteservice">
</ Accion>
</ Service>
</ Service>
</ Application>
</ Manifiesto>
Lanzamiento y unión al servicio remoto

Al igual que con un servicio unido local, el componente de cliente necesita implementar una instancia de la clase
ServiceConnection con onServiceConnected () y onServiceDisconnected () métodos. También en común con los
servicios locales, el método onServiceConnected () se pasará el objeto IBinder devuelto por el método onBind ()
del servicio remoto que se utiliza para enviar mensajes al controlador de servidor. En el caso de este ejemplo, el
cliente es RemoteBoundActivity, cuyo código se encuentra en RemoteBoundActivity.java. Cargar este archivo y
modificarlo para añadir la clase ServiceConnection y una variable para almacenar una referencia al objeto
Mensajero recibido junto con un indicador booleano para indicar si o no se establece la conexión:
com.ebookfrenzy.remotebound paquete;
android.os.Messenger importación;
android.os.RemoteException importación;
public class RemoteBoundActivity extiende ActionBarActivity {
Mensajero myService = null;

isBound boolean;
@ Override
setContentView (R.layout.activity_remote_bound);
}
ServiceConnection privado myConnection =

nueva ServiceConnection () {
public void onServiceConnected (ComponentName className,
IBinder servicio) {
myService = nuevo Messenger (servicio);
isBound = true;
}
public void onServiceDisconnected (ComponentName className) {

myService = null;
isBound = false;
}
};
.
.
.
}
A continuación, algo de código necesita ser añadido para unirse al servicio remoto. Esto implica la creación de
una intención que coincida con el filtro de intención para el servicio como se declara en el archivo de manifiesto
y luego hacer una llamada al método bindService (), proporcionando la intención y una referencia a la instancia
ServiceConnection como argumentos. Para los fines de este ejemplo, este código se ejecutará en el método
onCreate de la actividad ():
@ Override
setContentView (R.layout.activity_remote_bound);
Intención Intención =
nueva Intención ("com.example.remoteservice");
bindService (intención, myConnection, Context.BIND_AUTO_CREATE);
}
El envío de un mensaje al servicio remoto

Todo lo que queda antes de probar la aplicación es poner en práctica el método sendMessage () en la clase
RemoteBoundActivity que está configurado para ser llamado cuando el botón en la interfaz de usuario es tocado
por el usuario. Este método tiene que comprobar que el servicio está conectado, cree un objeto de lote que
contiene la cadena que se mostrará por el servidor, añadirlo a un objeto de mensaje y enviarlo al servidor:
public void sendMessage (Ver vista)

{
si el retorno (isBound!);
Msg Mensaje = Message.obtain ();
Haz Bundle = new Bundle ();

bundle.putString ("MyString", "mensaje recibido");
msg.setData (paquete);
try {
myService.send (msg);
} Catch (RemoteException e) {
e.printStackTrace ();
}
}
Con el código cambia completa, compilar y ejecutar la aplicación. Una vez cargado, toque el botón en la interfaz
de usuario, y en ese momento un mensaje de Toast debería aparecer que dice "mensaje recibido".
Resumen
Con el fin de poner en práctica la interacción entre un cliente y un servicio con destino a distancia, es necesario
implementar un marco de comunicación controlador / mensaje. Los conceptos básicos de esta técnica se han
cubierto en este capítulo junto con la implementación de una aplicación de ejemplo diseñado para demostrar la
comunicación entre un cliente y un servicio de encuadernado, cada uno en ejecución en un proceso separado.
39 An Overview of Android SQLite Databases in Android

Studio
Las aplicaciones móviles que no necesitan para almacenar al menos una cierta cantidad de datos persistentes
son pocos y distantes entre sí. El uso de bases de datos es un aspecto esencial de la mayoría de las
aplicaciones, que van desde las aplicaciones que están basadas en datos casi en su totalidad, a los que
simplemente necesitan almacenar pequeñas cantidades de datos, tales como la puntuación que prevalece de un
juego.
La importancia del almacenamiento de datos persistente se hace aún más evidente si se tiene en cuenta el ciclo
de vida un tanto transitoria de la aplicación típica Android. Con el riesgo siempre presente de que el sistema de
ejecución Android terminará un componente de aplicación para liberar recursos, una estrategia integral de
almacenamiento de datos para evitar la pérdida de datos es un factor clave en el diseño e implementación de
cualquier estrategia de desarrollo de aplicaciones.
En este capítulo se ofrecerá una visión general del sistema de gestión de base de datos SQLite incluido con el
sistema operativo Android, junto con un resumen de las clases del SDK de Android que se proporcionan para
facilitar persistente SQLite basada en almacenamiento de base de datos desde una aplicación Android. Antes
de profundizar en los detalles de SQLite en el contexto de desarrollo de Android, sin embargo, una breve
descripción de las bases de datos SQL y estará cubierta.
comprensión de las Tablas de base de datos
Tablas de la base proporcionan el nivel más básico de la estructura de datos en una base de datos. Cada base
de datos puede contener varias tablas y cada tabla está diseñada para mantener la información de un tipo
específico. Por ejemplo, una base de datos puede contener una tabla de clientes que contiene el nombre,
dirección y número de teléfono para todos los clientes de una empresa en particular. La misma base de datos
también puede incluir una tabla de productos utilizados para almacenar las descripciones de los productos con
códigos de los productos asociados a los artículos vendidos por la empresa.
Cada tabla de una base de datos se le asigna un nombre que debe ser único en la base de datos en
particular. Un nombre de tabla, una vez asignado a una tabla en una base de datos, sólo se podrá volver a
utilizar en el contexto de una base de datos diferente.
La introducción de esquemas de bases de datos

Base de datos de esquema definen las características de los datos almacenados en una tabla de base de
datos. Por ejemplo, el esquema de tabla para una tabla de base de datos cliente podría definir que el nombre
del cliente es una cadena de no más de 20 caracteres de longitud, y que el número de teléfono del cliente es un
campo de datos numérico de un determinado formato.
Esquema también se utilizan para definir la estructura de las bases de datos enteros y la relación entre las
diversas tablas contenidas en cada base de datos.
Las columnas y tipos de datos

Es útil en esta etapa para empezar a ver una tabla de base de datos como similar a una hoja de cálculo donde
se almacenan los datos en filas y columnas.
Cada columna representa un campo de datos en la tabla correspondiente. Por ejemplo, el nombre, dirección y
teléfono de datos campos de una tabla son todas las columnas.
Cada columna, a su vez, se define para contener un cierto tipo de datos que determina el tipo de datos de la
columna puede contener. Una columna diseñada para almacenar números sería, por lo tanto, se define como un
tipo de datos numérico.
Filas de bases de datos

Cada nuevo registro que se guarda en una tabla se almacena en una fila. Cada fila, a su vez, consta de las
columnas de datos asociados con el registro guardado.
Una vez más, tenga en cuenta la analogía de hoja de cálculo descrito anteriormente en este capítulo. Cada
entrada en una tabla de clientes es equivalente a una fila de una hoja de cálculo y cada columna contiene los
datos de cada cliente (nombre, dirección, teléfono, etc.). Cuando se agrega un nuevo cliente a la mesa, se crea
una nueva fila y los datos para ese cliente almacenado en las columnas correspondientes de la nueva fila.
Las filas también se conocen como registros o entradas y estos términos generalmente se pueden utilizar
indistintamente a veces.
La introducción de claves principales

Cada tabla de base de datos debe contener uno o más columnas que se pueden utilizar para identificar a cada
fila de la tabla única. Esto se conoce en la terminología de base de datos como la clave principal. Por ejemplo,
una tabla puede utilizar una columna de número de cuenta bancaria como la clave principal. Alternativamente,
una tabla de clientes puede utilizar el número de seguro social del cliente como la clave principal.
Las claves primarias permiten que el sistema de gestión de base de datos para identificar una fila específica en
una mesa única. Sin una clave principal no sería posible recuperar o eliminar una fila específica en una mesa
porque no puede haber certeza de que la fila correcta se haya seleccionado. Por ejemplo, supongamos que
existía una mesa donde el apellido del cliente había sido definida como la clave principal. Imagínese entonces el
problema que podría surgir si más de un cliente llamado "Smith" se registraron en la base de datos. Sin alguna
forma garantizada para identificar de forma única una fila específica, sería imposible garantizar Se está
accediendo a la información correcta, en un momento dado.
Las claves primarias pueden comprender una sola columna o varias columnas en una tabla. Para calificar como
una sola columna de clave principal, no hay dos filas pueden contener los mismos valores de clave primaria. Al
utilizar varias columnas para construir una clave principal, los valores de columna individuales no tienen que ser
únicos, pero todas las columnas combinadas deben ser únicos.
¿Qué es SQLite?
SQLite es una incorporado, sistema de gestión de bases de datos relacionales (RDBMS). La mayoría de las
bases de datos relacionales (Oracle y MySQL son los principales ejemplos) son procesos de servidor
independientes que se ejecutan de forma independiente, y en cooperación con las aplicaciones que requieren
acceso de base de datos. SQLite es referido como embebido, ya que se proporciona en la forma de una
biblioteca que está vinculada a las aplicaciones. Como tal, no hay un servidor de base de datos independiente
que se ejecuta en segundo plano. Todas las operaciones de base de datos se manejan internamente dentro de
la aplicación a través de las llamadas a funciones contenidas en la biblioteca SQLite.
Los desarrolladores de SQLite han colocado a la tecnología en el dominio público con el resultado de que ahora
es una solución de base de datos ampliamente desplegado.
SQLite está escrito en el lenguaje de programación C y, como tal, el SDK de Android proporciona una basada
"envoltorio" Java alrededor de la interfaz de base de datos subyacente.Consiste esencialmente en un conjunto
de clases que se pueden utilizar en el código Java de una aplicación para crear y administrar bases de datos
basadas SQLite.
Para obtener información adicional acerca de SQLite consulte http://www.sqlite.org .
Structured Query Language (SQL)

Se accede a los datos en bases de datos SQLite usando un lenguaje de alto nivel conocido como Structured
Query Language. Esto normalmente se abrevia a SQL y secuela pronunciado.SQL es un lenguaje estándar
utilizado por la mayoría de los sistemas de gestión de bases de datos relacionales. SQLite conforma
principalmente con el estándar SQL-92.
SQL es esencialmente un lenguaje muy simple y fácil de usar diseñado específicamente para permitir la lectura
y escritura de datos de bases de datos. Dado que SQL contiene un pequeño conjunto de palabras clave, se
puede aprender rápidamente. Además, la sintaxis SQL es más o menos idéntico entre la mayoría de las
implementaciones de DBMS, así que después de haber aprendido de SQL para un sistema, es probable que
sus habilidades se trasladarán a otros sistemas de gestión de bases de datos.
Mientras que algunas de las declaraciones SQL básicas serán utilizados dentro de este capítulo, una
descripción detallada de SQL está más allá del alcance de este libro. Sin embargo, hay muchos otros recursos
que proporcionan una mejor visión general de SQL de lo que podríamos esperar para ofrecer en un solo capítulo
aquí.
Tratando SQLite en un dispositivo virtual de Android (AVD)

Para los lectores no familiarizados con las bases de datos en general y SQLite en particular, buceo derecho a la
creación de una aplicación para Android que utiliza SQLite puede parecer un poco
intimidante. Afortunadamente, Android se envía con preinstalado SQLite, incluyendo un entorno interactivo para
emitir comandos SQL desde una sesión adb shell conectado a una instancia de emulador de Android AVD
correr. Esto es tanto una manera útil de aprender sobre SQLite y SQL, y también una valiosa herramienta para
la identificación de problemas con las bases de datos creadas por las aplicaciones que se ejecutan en un
emulador.
Para iniciar una sesión interactiva SQLite, comience ejecutando una sesión de AVD. Esto puede lograrse desde
dentro Android Estudio lanzando el Android Device Manager Virtual (Herramientas -> Android -> Administrador
de AVD), la selección de una AVD configurado previamente y haciendo clic en Inicio.
Una vez que la AVD está en funcionamiento, abra una ventana de terminal o símbolo del sistema y conectar con
el emulador utilizando la herramienta de línea de comandos adb de la siguiente manera (en cuenta que el
indicador -e dirige la herramienta para buscar un emulador con el que conectar, en lugar de un dispositivo
físico):
shell -e adb
Una vez conectado, el entorno de shell proporcionará un símbolo del sistema en el que podrá introducir órdenes:
root @ android: / #
Los datos almacenados en bases de datos SQLite se almacenan realmente en los archivos de base de datos en
el sistema de archivos del dispositivo Android en el que se ejecuta la aplicación. De forma predeterminada, la
ruta del sistema de archivos para estos archivos de base de datos es el siguiente:
/ Data / / <nombre del paquete> datos / bases de datos / <nombre del archivo de
base de datos> .db
Por ejemplo, si una aplicación con el nombre del paquete com.example.MyDBApp crea una base de datos
llamada mydatabase.db, la ruta de acceso al archivo en el dispositivo con el siguiente texto:
/data/data/com.example.MyDBApp/databases/mydatabase.db
A los efectos de este ejercicio, por lo tanto, cambie el directorio a / data / datos dentro del adb shell y crear una
jerarquía subdirectorio adecuado para un poco de experimentación SQLite:
cd / datos / datos
mkdir com.example.dbexample
com.example.dbexample cd
bases de datos mkdir
bases de datos de cd
Con una ubicación adecuada creado para el archivo de base de datos, inicie la herramienta SQLite interactivo
de la siguiente manera:
root @ android: / datos / datos / bases de datos # sqlite3 ./mydatabase.db

sqlite3 ./mydatabase.db
SQLite versión 3.7.4
Enter ".help" para obtener instrucciones
Introduzca sentencias SQL terminados con un ";"
sqlite>
Al sqlite> y podrá introducir órdenes para llevar a cabo tareas como la creación de tablas e insertar y recuperar
datos. Por ejemplo, para crear una nueva tabla en la base de datos con los campos para contener ID, nombre,
dirección y número de teléfono campos se requiere la siguiente declaración:
crear contactos de mesa (autoincrement _id entero primaria clave, texto nombre,
dirección de texto, texto del teléfono);
Tenga en cuenta que cada fila de una tabla debe tener una clave principal que es único para esa fila. En el
ejemplo anterior, hemos designado el campo ID como clave principal, declarado como de tipo entero y pidió
SQLite para incrementar automáticamente el número cada vez que se agrega una fila. Esta es una manera
común para asegurarse de que cada fila tiene una clave principal única. En la mayoría de las otras plataformas,
la elección del nombre para la clave principal es arbitraria. En el caso de Android, sin embargo, es esencial que
la clave será nombrado _id para que la base de datos para ser totalmente accesible utilizando todas las clases
relacionadas con la base de datos Android. Los campos restantes son cada declarados como de tipo texto.
Para una lista de las tablas en la base de datos seleccionada, utilice la sentencia .tables:
sqlite> .tables
contactos
Para insertar registros en la tabla:
sqlite> insertar en los valores de contactos (nombre, dirección, teléfono) ("David

Smith", "123 Main Street, California", "123-555-2323");
sqlite> insertar en los valores ("Mark Parques", "10 Upping Street, Idaho", "444-
444-1212") contactos (nombre, dirección, teléfono);
Para recuperar todas las filas de una tabla:
sqlite> select * from contactos;

1 | David Smith | 123 Main Street, California | 123-555-2323
2 | Marcar Parques | 10 Upping Street, Idaho | 444-444-1212
Para extraer una fila que cumpla con criterios específicos:

sqlite> select * from contactos donde name = "Marca Parques";
2 | Marcar Parques | 10 Upping Street, Idaho | 444-444-1212
Para salir del entorno interactivo sqlite3:
sqlite> .exit
Cuando se ejecuta una aplicación Android en el entorno emulador, todos los archivos de base de datos se
pueden crear en el sistema de archivos del emulador utilizando la convención de ruta discutido
previamente. Esto tiene la ventaja de que se puede conectar con adb, navegue hasta la ubicación del archivo de
base de datos, cargarlo en la herramienta interactiva sqlite3 y realizar tareas en los datos para identificar
posibles problemas que ocurren en el código de la aplicación.
También es importante señalar que, si bien es posible conectar con un adb shell a un dispositivo Android física,
el depósito no se concede privilegios suficientes por defecto para crear y gestionar bases de datos
SQLite. Depuración de los problemas de base de datos es, por lo tanto, realiza mejor utilizando una sesión de
AVD.
Clases Android SQLite Java

SQLite es, como se mencionó anteriormente, escrito en el lenguaje de programación C, mientras que las
aplicaciones de Android se desarrollan principalmente utilizando Java. Para cerrar esta "brecha del idioma", el
SDK de Android incluye un conjunto de clases que proporcionan una capa de Java en la parte superior del
sistema de gestión de base de datos SQLite. El resto de este capítulo proporcionará una descripción básica de
cada una de las clases principales dentro de esta categoría. Más detalles sobre cada clase se pueden encontrar
en la documentación en línea Android.
Cursor
Una clase proporcionado específicamente para proporcionar acceso a los resultados de una consulta de base
de datos. Por ejemplo, una operación de SQL SELECT se realiza en una base de datos potencialmente volverá
múltiples filas coincidentes de la base de datos. Un ejemplo Cursor se puede utilizar para pasar a través de
estos resultados, que pueden entonces accederse desde dentro del código de la aplicación utilizando una
variedad de métodos. Algunos métodos clave de esta clase son como sigue:
 close () - Libera todos los recursos utilizados por el cursor y lo cierra.
 getCount () - Devuelve el número de filas que aparecen en el conjunto de resultados.
 moveToFirst () - Se desplaza a la primera fila en el conjunto de resultados.
 moveToLast () - Se desplaza a la última fila del conjunto de resultados.
 MoveToNext () - Se desplaza a la siguiente fila del conjunto de resultados.
 mover () - Se mueve por un desplazamiento especificado desde la posición actual del conjunto de
resultados.
 llegar <tipo> () - Devuelve el valor de la <tipo> especificada contenida en el índice de la columna
especificada de la fila en la posición actual del cursor (variaciones consisten en getString (), getInt (),
getShort (), getFloat () y getDouble ()).
SQLiteDatabase
Esta clase proporciona la interfaz principal entre el código de la aplicación y bases de datos SQLite subyacentes
incluyendo la capacidad de crear, eliminar y realizar operaciones basadas en SQL en bases de datos. Algunos
métodos clave de esta clase son como sigue:
 insert () - Inserta una nueva fila en una tabla de base de datos.
 delete () - Elimina filas de una tabla de base de datos.
 query () - Realiza una consulta de base de datos especificado y devuelve resultados que cumplan a
través de un objeto Cursor.
 execSQL () - Ejecuta una única sentencia SQL que no devuelve datos de resultados.
 rawQuery () - Ejecuta una sentencia de consulta SQL y devuelve los resultados que coinciden en la
forma de un objeto Cursor.
SQLiteOpenHelper
Una clase de ayuda diseñado para que sea fácil crear y actualizar bases de datos. Esta clase debe tener
subclases dentro del código de la demanda que tenga acceso a la base y los siguientes métodos de devolución
de llamada implementados dentro de esa subclase:
 onCreate () - Se llama cuando se crea la base de datos por primera vez. Este método se pasa como
argumento el objeto SQLiteDatabase para la nueva base de datos. Este es el lugar ideal para inicializar la
base de datos en cuanto a la creación de una tabla e insertar las filas de datos iniciales.
 ONUPGRADE () - Llamado en el caso de que el código de la aplicación contiene una versión de la
base de datos de referencia número más reciente. Esto se utiliza normalmente cuando una aplicación se
actualiza en el dispositivo y requiere que el esquema de base de datos también se actualizará para manejar
el almacenamiento de datos adicionales.
Además de los métodos de devolución de llamada obligatorios anteriormente, el método onOpen (), llamada
cuando se abre la base de datos, también puede implementarse dentro de la subclase.
El constructor de la subclase también deben ser aplicadas para llamar a la super clase, pasando por el contexto
de aplicación, el nombre de la base de datos y la versión de la base de datos.
Métodos notables de la clase SQLiteOpenHelper incluyen:
 getWritableDatabase () - Abre o crea una base de datos para la lectura y la escritura. Devuelve una
referencia a la base de datos en la forma de un objeto SQLiteDatabase.
 getReadableDatabase () - Crea o abre una base de datos para sólo lectura. Devuelve una referencia
a la base de datos en la forma de un objeto SQLiteDatabase.
 close () - Cierra la base de datos.
ContentValues
ContentValues es una clase de conveniencia que permite a los pares clave / valor que se declare que consiste
en la tabla de identificadores de columna y los valores que se almacenan en cada columna. Esta clase es de
uso particular al insertar o actualizar las entradas en una tabla de base de datos.
Resumen
SQLite es un sistema ligero, embebido relacional de gestión de base de datos que se incluye como parte del
marco de Android y proporciona un mecanismo para la implementación del almacenamiento de datos
persistente organizado para aplicaciones de Android. Además de la base de datos SQLite, el marco Android
también incluye una serie de clases Java que pueden utilizarse para crear y gestionar bases de datos y tablas
basadas SQLite.
El objetivo de este capítulo ha sido proporcionar una visión general de las bases de datos en general y SQLite
en particular en el contexto del desarrollo de aplicaciones para Android. Los próximos capítulos trabajarán a
través de la creación de una aplicación de ejemplo la intención de poner en práctica esta teoría en la forma de
un tutorial paso a paso. Desde la interfaz de usuario de la aplicación ejemplo requerirá un diseño basado en las
formas, el primer capítulo, titulado Un TableLayout y TableRow Tutorial Android Estudio , desviará ligeramente
del tema central mediante la introducción de los conceptos básicos de las opiniones TableLayout y TableRow.
40 Un Android Estudio TableLayout y TableRow Tutorial
Cuando el trabajo se inició en el siguiente capítulo de este libro ( Un Tutorial Database Android Estudio SQLite )
fue pensado originalmente que incluiría los pasos para diseñar el diseño de la interfaz de usuario de la
aplicación de ejemplo de base de datos. Rápidamente se hizo evidente, sin embargo, que la mejor manera de
implementar la interfaz de usuario era hacer uso de los puntos de vista Android TableLayout y TableRow y que
esta área tema merecía un capítulo autónomo. Como resultado, este capítulo se centrará únicamente en el
diseño de interfaz de usuario de la aplicación de base de datos completa en el siguiente capítulo, y al hacerlo,
tomar algún tiempo para introducir los conceptos básicos de los diseños de tabla en Android Studio.
Las TableLayout y TableRow Disposición Vistas

El propósito de la vista de contenedor TableLayout es permitir que elementos de la interfaz de usuario que se
organizarán en la pantalla en un formato de tabla consta de filas y columnas.Cada fila dentro de un TableLayout
está ocupado por una instancia de TableRow, que, a su vez, se divide en celdas, cada celda que contiene una
única vista niño (que puede ser en sí misma un recipiente con múltiples ver a los niños).
El número de columnas de una tabla es dictado por la fila con el mayor número de columnas y, por defecto, el
ancho de cada columna se define por la célula más amplia en esa columna.Las columnas pueden ser
configurados para ser retráctil o estirable (o ambos) de modo que cambian de tamaño en relación con el
TableLayout padres. Además, una única célula puede estar configurado para abarcar varias columnas.
Considere el diseño de la interfaz de usuario se muestra en la Figura 41-1:
Figura 41-1
Desde el aspecto visual de la disposición, es difícil identificar la estructura TableLayout utilizado para diseñar la
interfaz. El árbol jerárquico ilustrado en la Figura 41-2, sin embargo, hace que la estructura un poco más fácil de
entender:
Figura 41-2
Claramente, el diseño consiste en una vista LinearLayout padre con TableLayout y LinearLayout niños. El
TableLayout contiene tres hijos TableRow representan tres filas de la tabla. Los filastabla contienen dos puntos
de vista del niño, con cada niño representa el contenido de una celda de la columna. El punto de vista del niño
LinearLayout contiene tres hijos Button.
El diseño se muestra en la Figura 41-2 es la disposición exacta que se requiere para el ejemplo de base de
datos que se completará en el próximo capítulo. El resto de este capítulo, por lo tanto, se puede utilizar para
trabajar paso a paso en el diseño de esta interfaz de usuario usando la herramienta Android Studio Designer.
Crear el proyecto de base de datos

Iniciar Android Studio y crear un nuevo proyecto, entrando base de datos en el campo Nombre de la aplicación y
actividad en blanco denominada DatabaseActivity con una disposición correspondiente llamado
activity_database.
Agregar el TableLayout a la interfaz de usuario

Busque el archivo activity_database.xml en la ventana de la herramienta de Proyectos (Base de datos ->
aplicación -> src -> principal -> res -> layout) y haga doble clic en él para cargarlo en la herramienta
Diseñador. Con la herramienta de diseño en modo Diseño, seleccione el objeto TextView ejemplo de la
disposición y pulse la tecla para eliminarlo de la disposición Eliminar el teclado.
Por defecto, Android Studio ha utilizado un RelativeLayout como el elemento de diseño raíz en la interfaz de
usuario. Esto necesita ser reemplazado por un LinearLayout orientado verticalmente. En el panel Árbol de
componentes, localice y seleccione la instancia RelativeLayout y sacarlo de la interfaz de usuario usando la
tecla Suprimir del teclado.
Localice el componente LinearLayout (vertical) de la sección Diseños de la paleta Diseñador y arrastre y suéltelo
en el diseño de la pantalla del dispositivo.
Una vez más, refiriéndose a la sección Diseños de la paleta, arrastrar y soltar una vista TableLayout de manera
que se coloca en la parte superior de la zona de la lona LinearLayout como se ilustra en la Figura 41-3:
Figura 41-3
Una vez que estos pasos iniciales están completos, el Árbol de componentes para el diseño debe parecerse a la
que se muestra en la Figura 41-4:
Figura 41-4
Agregar y configurar los filastabla

Ahora que el TableLayout ha sido añadido a la disposición de la interfaz de usuario, tres casos TableRow
necesitan ser añadido como niños. Desde la paleta Diseñador, busque la entrada TableRow enumerados en
presentaciones y arrastrar y soltar una instancia directamente sobre la parte superior de la entrada TableLayout
en el panel Árbol de componentes. Repita este paso para agregar dos filastabla más para que el árbol de
componentes coincide Figura 41-5:
Figura 41-5
Desde dentro de la sección Widgets de la paleta, arrastre y suelte dos grandes objetos de texto TextView en la
entrada TableRow superior del árbol de componentes (Figura 41-6):
Figura 41-6
Doble click en la más TextView izquierda dentro del diseño de la pantalla y, en el panel de configuración de
propiedades rápida, cambie la propiedad de texto a "Identificación del producto".Repita este paso para el
derecho más TextView, cambiando esta vez el texto a "Sin asignar" y especificando un valor id de @ + /
Identificación del IDproducto. Extrae el texto de cada TextView a nuevos recursos de cadena utilizando la
bombilla icono aparece cuando se selecciona la vista.
Arrastre y suelte otra vista de texto grande y una edición del texto en Texto sin formato de la sección de campos
de texto de la paleta en la segunda entrada TableRow en el árbol de componentes. Cambie el texto en el
TextView a Nombre del producto y el ID del objeto EditarTexto a @ + / Identificación del productName.
Arrastre y suelte otra vista de texto sin formato y un Número (Decimal) Campo de texto en el tercer
TableRow. Cambie el texto en el TextView al Producto Cantidad y el ID del objeto de campo de texto para @ + /
Identificación del productQuantity. Antes de continuar, asegúrese de extraer todas las propiedades de texto
añadido en los pasos anteriores a recursos de cadena.
Adición de la barra de botones para el diseño

El siguiente paso es añadir un LinearLayout (Horizontal) vista a la vista de los padres LinearLayout, situado
inmediatamente debajo de la vista TableLayout. Arrastre y suelte un (Horizontal) LinearLayout instancia de la
sección Diseños de la paleta Diseñador y colocarla directamente en la entrada LinearLayout (vertical) en el
panel Árbol de componentes.
Arrastre y suelte los tres objetos Button en el nuevo LinearLayout y asignar recursos de cadena para cada botón
que decía "Añadir", "Buscar" y "Borrar", respectivamente.
Con la nueva visión horizontal lineal Diseño seleccionado en el árbol de componentes, haga clic en el botón de
la gravedad en la barra de herramientas de diseño (Figura 41-7) y seleccione la opción Centro de gravedad para
que los botones están centradas horizontalmente dentro de la pantalla:
Antes de continuar, compruebe también la jerarquía de la composición en el panel Árbol de componentes,
teniendo especial cuidado para asegurar la vista los nombres de identificación coinciden con los de la figura
siguiente:
Figura 41-8
Ajuste de los márgenes de disposición

Todo lo que queda es ajustar algunos de los ajustes de diseño. Comience haciendo clic en la primera entrada
TableRow en el panel Árbol de componentes para que se seleccione. Mantenga presionada la tecla Ctrl del
teclado y haga clic en el segundo y tercer filastabla manera que se seleccionan los tres elementos. En el panel
Propiedades, busque la disposición: margen categoría de propiedad y, una vez localizado, despliegue la
categoría y cambiar la configuración de todos a 10DP como se muestra en la Figura 41-9:
Figura 41-9
Con márgenes establecidos en los cuatro lados de los tres filastabla, la interfaz de usuario debería aparecer
como se ilustra en la Figura 41-1. En aras de la exhaustividad, y para fines de comparación en el caso de que su
diseño no coincide con el de la figura 41-1, la estructura activity_database.xml completa para este diseño se
describe a continuación.
<LinearLayout
<TableLayout
android: layout_gravity = "center_horizontal">
<TableRow
android: layout_margin = "10DP">
<TextView
android: text = "@ string / id_string"
android: id = "@ + / Identificación del TextView" />
<TextView
android: text = "No asignado"
android: id = "@ + / Identificación del IDproducto" />
</ TableRow>
<TableRow
<TextView
android: text = "@ string / product_string"
android: id = "@ + / Identificación del textView3" />
<EditarTexto
android: id = "@ + / Identificación del productName" />
</ TableRow>
<TableRow
<TextView
android: text = "@ string / quantity_string"
android: id = "@ + / Identificación del textView2" />
<EditarTexto
android: InputType = "numberDecimal"
android: ems = "10"
android: id = "@ + / Identificación del productQuantity" />
</ TableRow>
</ TableLayout>
<LinearLayout
android: layout_gravity = "center_horizontal"
<Botón
android: text = "@ string / add_string"
android: id = "/ botón @ + id" />
<Botón
android: text = "@ string / find_string"
android: id = "@ + / Identificación del button2" />
<Botón
android: text = "@ string / delete_string"
android: id = "@ + / Identificación del button3" />
</ LinearLayout>
</ LinearLayout>
Resumen
La vista contenedor Android TableLayout proporciona una manera de organizar ver los componentes en una
configuración de filas y columnas. Mientras que la vista TableLayout proporciona el contenedor general, cada
fila, y las células contenidas en el mismo, se aplican a través de las instancias de la vista TableRow. En este
capítulo, una interfaz de usuario ha sido diseñado en Android Studio usando los contenedores TableLayout y
TableRow. El siguiente capítulo se sumará la funcionalidad detrás de esta interfaz de usuario para implementar
las capacidades de base de datos SQLite.

Android Estudio de Desarrollo de Essentials

Cargado por

Información del documentohacer clic para expandir la información del documento

Copyright:

Formatos disponibles

Android Estudio de Desarrollo de Essentials

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Android Estudio de Desarrollo de Essentials

Cargado por

Copyright:

Formatos disponibles

Android estudio de desarrollo de Essentials

Requisitos del sistema

2 Creación de una aplicación Android en Android Ejemplo Estudio

Requisitos del sistema

Instalación del Java Development Kit (JDK)

Instalación de Windows JDK

java version "1.6.0_65"

Sin tiempo de ejecución de Java actual, solicitando instalar

Instalación de Linux JDK

sudo apt-get install ia32-libs

tar xvfz <jdk-file> .tar.gz

export PATH = / home / demo / java / jdk1.7.0_45 / bin: $ PATH

La descarga del paquete Android Estudio

tar xvf / <ruta de acceso al paquete> / android-studio-Bundle- <versión> .tgz

Tenga en cuenta que el paquete Android estudio se instalará en un androide-estudio sub-directorio

Instalación de los últimos paquetes SDK de Android

 Herramientas> Herramientas del SDK de Android

 Extras -> Android Ayuda Repositorio

Hacer las herramientas del SDK de línea de comandos Android Accesible

<path_to_android_studio_installation> / sdk / herramientas

Los pasos para lograr este sistema están operando dependiente:

; C: \ Users \ demo \ android-studio \ sdk \ Platform-tools; C: \ Users \ demo \

"Adb" no se reconoce como un comando interno o externo,

"Adb" no se reconoce como un comando interno o externo,

/ Aplicaciones / Android Studio.app / SDK / herramientas

2 Creación de una aplicación Android en Android Ejemplo

Creación de un nuevo proyecto de Android

Definición de la configuración del proyecto y SDK

Modificación del ejemplo de aplicación

[I18N] cadena codificada "Bienvenido a Android Studio", debe utilizar los

<RelativeLayout xmlns: android = "http://schemas.android.com/apk/res/android"

<? Xml version = "1.0" encoding = "UTF-8"?>

<String name = "nombre_apl"> AndroidSample </ string>

Vista previa de la Disposición

3 Un recorrido por la interfaz de usuario de Android Estudio

Los diversos elementos de la ventana principal se pueden resumir como sigue:

 C - Barra de navegación - La barra de navegación proporciona una manera conveniente para

 Mensajes - La herramienta de mensajes de registros de las ventanas de salida del sistema de

 Android - El ventana de la herramienta Android proporciona acceso al sistema de depuración

Switcher y archivos recientes Navegación

Cambiar el tema Android Estudio

4 Creación de un dispositivo virtual de Android (AVD) en

Acerca de los dispositivos virtuales de Android

Creación de una nueva AVD

Inicio del emulador

Ejecutar la aplicación en la AVD

Ejecutar / depurar Configuraciones

Detener una aplicación en ejecución

De línea de comandos AVD Creación

objetivos lista android

Disponible objetivos Android:

La sintaxis para la creación de AVD es como sigue:

Android crear avd -n <nombre> -t <targetID> [- <option> <valor>]

androide crear avd -n Nexus7 -t 1

lista androide avd

C: \ Users lista \ nas> androide avd

Android eliminar avd -name <avd nombre>

Archivos de configuración de dispositivos virtuales de Android