Aventuras Android con Android Estudio

Contenido

1. Primeros pasos con Android Estudio

2. La actividad y el interfaz de usuario

3. La construcción de la interfaz de usuario y una calculadora App

4. Controles básicos y Eventos

5. Contenedores de diseño

6. Ciclo de Vida y Estado

7. Spinners

8. Pickers

9. IU Gráficos A Deep Dive

10. ListView y adaptadores 

Fragmentos

11. Presentación de Fragmentos

12. Fragmentos y XML

13. Fragmento Y Actividad Trabajando Juntos

14. Gestión de Fragmentos

15. Diálogos personalizados utilizando DialogFragment

16. Clases de diálogo en el DialogFragment

17. Un Proyecto NumberPicker DialogFragment

18. ViewPager

1. Primeros pasos con Android Estudio

Android representa un gran mercado potencial. También es el más abierto de los "grandes" plataformas de teléfonos. Todas las herramientas que necesita para crear una aplicación Android son gratuitos. Don; t tienen que pagar nada para unirse a un club para crear e incluso distribuir tu aplicación Android. Si quieres vender a través de un mercado conocido como Google Play o Amazon entonces no es por lo general una pequeña cuota anual, pero usted no tiene que utilizar cualquier método de distribución particular.

Todo lo que se interpone entre usted y su aplicación para Android es su imaginación y capacidad de programación. No puedo hacer mucho para mejorar tu imaginación pero puedo ayudar con el lado de la programación de las cosas.

En este ebook le mostraré los fundamentos de la programación Android. No los consejos y trucos, pero la forma de pensar acerca de lo que está pasando - es decir, los principios

generales que harán posible que usted pueda dominar cualquier cosa que usted encuentra que es nuevo en el futuro.

¿Qué es lo que necesita saber para empezar?

¡Tienes que ser capaz de programar en un lenguaje orientado a objetos modernos. Java sería mejor, ya que es el idioma que se utiliza para crear aplicaciones de Android, pero C #, C ++, VB o algo similar está lo suficientemente cerca en espíritu a Java para que usted sea capaz de hacer frente. Usted puede ser que también tenga que buscar cosas sobre los detalles de las características particulares de Java, pero la mayoría del tiempo, debería ser obvio o evidente con la ayuda de algunos comentarios.

No es necesario ser un experto programador porque para una gran cantidad de programación Android simplemente está utilizando las características y facilidades previstas - que es una gran cantidad de programación Android es sólo una cuestión de seguir las reglas.

Sin embargo si la esperanza de crear algo único y útil que usted en algún momento tiene que añadir algo de su propio - y aquí se requiere creatividad y habilidad. Así que es posible que no necesita ser un experto programador para empezar pero que necesita para convertirse en uno para el momento de crear su aplicación sorprendente.

Afortunadamente la práctica es un buen maestro y así aprender a código para Android en realidad ayudará a aprender a código.

Empezando

Este es un muy buen momento para empezar a trabajar con Android porque Google ha lanzado Android Estudio que es una herramienta fácil de usar Android IDE - Integrated Development Environment.

Antes de que esto se tenía que utilizar el Eclipse IDE y configuración del SDK y otras piezas de software necesario.Esto no fue difícil, pero Android Studio facilita y hace que la programación Android fácil. En pocas palabras, es el camino del futuro, así que vale su inversión en aprenderlo.

Con el lanzamiento de Android Estudio Google ha dejado de trabajar en el complemento de Eclipse y esto significa que Android Estudio realmente es la única forma de desarrollar aplicaciones a partir de ahora.

Así que para empezar.

Yo no voy a pasar mucho tiempo a explicar cómo instalar Android Estudio de una manera paso a paso - el sitio web de Android hace un buen trabajo y es más probable que sea hasta a la fecha. Vale la pena, sin embargo sólo va en los principios básicos.

En primer lugar asegúrese de que tiene la última Java JDK instalado - al menos JDK 6.

Si usted no tiene visita instalado Java: Java Descargar

Una vez que tenga la configuración de Java hasta Android Studio es fácil:

1. Descargue el paquete de Android Studio desde la página de Android Estudio Home .

2. Instalar Android Estudio que también instala todos el SDK de Android y las herramientas que necesitará:

Ventanas:

1. Inicie el archivo EXE descargado, android-studio-bundle-<version>.exe .

2. Siga el asistente de instalación para instalar Android Studio. 

Mac OS X:

3. Abra el archivo DMG descargado, android-studio-bundle-<version>.dmg .

4. Arrastre y suelte Android Estudio en la carpeta Aplicaciones.

Linux:

5. Descomprimir el archivo ZIP descargado,android-studio-bundle-<version>.tgz , en un lugar apropiado para sus aplicaciones.

6. Para lanzar Android de estudio, navegue hasta elandroid-studio/bin/ directorio en un terminal y ejecutar studio.sh .

Es posible que desee agregar android-studio/bin/ a la variable de entorno PATH, para que pueda empezar a Android Studio desde cualquier directorio.

Acepte los valores predeterminados que el programa de instalación le ofrece - a menos que tenga una buena razón para no hacerlo. Se instala no sólo Android de estudio, pero el SDK, el dispositivo virtual y si usted está utilizando una máquina basada en Intel un acelerador de dispositivo virtual.

En algunos sistemas Windows, el script lanzador no encuentra donde está instalado Java y usted encontrará que usted no puede ejecutar el recién instalado Android Studio. Parece que empezar y luego simplemente se desvanece.

Si se produce este problema, es necesario establecer una variable de entorno que indica la ubicación correcta del JDK de Java.

Seleccionar

Start menu > Computer > System Properties > Advanced System Properties.

A continuación, abra

Advanced tab > Environment Variables, add new system variable

y JAVA_HOME configuración que apunta a la carpeta de JDK, por ejemplo C: Program \ Files \ Java \ jdk1.7.0_21.

Hay un segundo problema que se detiene algunas instalaciones de trabajo. Así como JAVA_HOME está establecida en el directorio jdk también necesita un set PATH para el directorio bin. Utilice el mismo método para configurar las variables de entorno, pero seleccione la variable de la ruta existente y utilizar el botón Editar para agregar una ruta al directorio bin del JDK, por ejemplo, C: \ Archivos de programa \ Java \ jdk1.7.0_21 \ bin. Nota, usted tiene que utilizar un separador de punto y coma entre cada una de las rutas de los directorios especificados como parte de la variable PATH.

Ahora usted debería ser capaz de ejecutar Android Studio. Si no la causa más probable del problema es el JDK y así volver a la instalación es una mejor primera opción.

Su primer programa

Usted puede optar por iniciar Android Studio después de la instalación. Probablemente no va a ir directo al Android Estudio la primera vez que se inicia, ya que descarga actualizaciones para sí mismo y para el SDK de Android. Sólo tienes que ser paciente.

Cuando finalmente se pone en marcha, verá la pantalla de bienvenida:

Si ya ha creado algunos programas que bien podría verlos enumeran en proyectos recientes.

Asumiendo que este es su primer proyecto seleccionar el inicio de una nueva opción de proyecto Android Studio.

Puede pasar por alto los detalles del nuevo proyecto por el momento. Todo lo que tienes que hacer es suministrar un nombre para su aplicación - HelloWorld en este caso. Acepte el otro defecto que Android Studio ha rellenado para usted.

Al hacer clic en Siguiente se le da la oportunidad de elegir qué dispositivos que usted está apuntando. Una vez más, simplemente aceptar los valores predeterminados:

Página 2 de 4

La siguiente página le permite seleccionar una plantilla para su proyecto. En este caso, la actividad en blanco por defecto es lo que necesita. Todas las aplicaciones Android se compone de al menos sobre la Actividad y esta plantilla genera un proyecto con una sola Actividad listo para personalizar.

La siguiente página le permite asignar nombres personalizados para los distintos componentes de su proyecto que la plantilla genera. Para un proyecto real que le asigne nombres que eran significativos, pero en este caso se puede aceptar los valores predeterminados:

Por último, puede hacer clic en el botón Finalizar y espere a Android Studio crea todos los archivos que necesita. Incluso un proyecto Android sencillo tiene un montón de archivos así que de nuevo todo lleva su tiempo.

Primera vista

Cuando todo esté listo, verá Android Studio por primera vez.

Problemas?Si recibe algún mensaje de error - ".? Estilos que falta es el tema correcto elegido para este diseño" como lo más probable es que usted tiene algunas sobras de una instalación

anterior.Algunas veces la única manera de arreglar esto es borrar toda la .android, AndroidStudio y directorios .gradle usted y puede luego volver a instalar. Si tiene proyectos existentes entonces no elimine AndroidStudioProjects.

Antes de hacer nada de esto sin embargo, vale la pena probar el archivo, Invalidate Caches comando / Reiniciar. Esto generalmente funciona para "estilos Missing" y errores similares.

Mientras todo ha trabajado usted debe ser presentado con una vista de su nuevo proyecto partiendo en el diseñador seleccionado.

Aunque no se parece mucho a dominar en la interfaz de usuario de Android Estudio mayor parte de ella sólo se visita de vez en cuando. Las cosas importantes a notar son que se mueve de izquierda a derecha se tiene:

la ventana de proyecto

La división de diseño en su paleta y una ventana Layout

Una ventana de árbol de componentes y una ventana de propiedades en el extremo derecho.

La mayor parte del tiempo que va a utilizar la ventana del proyecto y la ventana Propiedades. En el entre los dos verá diferentes editores, dependiendo de qué tipo de archivo que ha seleccionado.

en este caso, usted tiene por defecto un archivo de diseño - activity_main.xml - seleccionado y por lo tanto tiene un editor de diseño en el centro de la pantalla.

Más sobre el diseño un poco más tarde - en primer lugar, es importante que usted sabe un poco acerca de la estructura de archivos de un proyecto para que pueda desplazarse a sus diferentes partes.

Estructura básica de proyectos

Cuando el proyecto se ha terminado de construir todos los archivos creados se pueden ver mediante la apertura de la ficha Proyectos. Lo más importante a notar es que hay un gran número de carpetas y archivos.

Se parece casi increíble que la aplicación para Android más simple que puede crear involucra tantos archivos.

No entre en pánico.

La mayoría de los archivos que se han creado son generados automáticamente y la mayoría de las veces usted no necesita saber nada acerca de ellos y mucho menos abierta o editarlos.En la apertura de hecho y los archivos generados automáticamente edición realmente no es una buena idea.

Así que vamos a centrarnos en los archivos que son importantes para nosotros.

Para nuestro programa simple que sólo hay dos archivos importantes que determina el comportamiento de la actividad

MainActivity.java

y uno que determina la mayor parte de la apariencia visual

Main_Activity.xml

Puede establecer que la actividad es la que se inicia el sistema pero por defecto es la actividad que creó y nombró al configurar el proyecto.

En este caso hemos llamado a la actividad MainActivity y su Main_Activity archivo de diseño - pero se puede cambiar estos valores predeterminados.

Usted puede ver la ubicación de estos dos archivos importantes en la ventana del proyecto:

El directorio de java es desde su punto de vista en la mayor parte de la construcción de su aplicación se produce así que asegúrate de saber donde está. El directorio de res es donde se guardan todos los recursos - diseños, mapas de bits, etc. que APP necesidades.

Así, mientras que las cosas se ven complicadas por el momento las únicas dos archivos de proyecto que te importan, y su proyecto, son MainActivity.java y activity_main.xml.

Anatomía de una actividad

Una aplicación para Android se compone de una o más actividades.

Usted puede pensar en una actividad como siendo algo así como una página web completa con HTML para determinar lo que muestra y JavaScript para determinar lo que hace.

En el caso de una actividad que el diseño se determina por el archivo XML en (res) directorio de recursos y el comportamiento se determina por el código Java en el directorio de Java.

El XML puede ser pensado como un lenguaje de marcas muy parecido a HTML o XAML.

Define un diseño inicial para la pantalla cuando la aplicación se ejecuta en primer lugar. Es posible generar nuevos componentes de diseño en tiempo de ejecución desde el archivo Java. De hecho, si de verdad quieres puedes prescindir del archivo XML y generar todo de Java, pero como usted descubrirá el enfoque marcado XML es mucho la mejor manera de hacer el trabajo - debido a la disponibilidad del diseñador.

Así que para ser 100% claro:

el archivo java contiene el código que hace que su aplicación se comportan de maneras particulares

y

el archivo de diseño .xml contiene una definición de la interfaz de usuario intial de su aplicación.

Echemos un vistazo a los dos archivos que se han generado para nuestra aplicación Hello World inicial comenzando con el diseño XML.

Página 3 de 4

Hola Diseñador

Primero veamos el archivo de diseño XML.

Doble click en activity_main.xml archivo en la ficha Proyecto y el archivo se abrirá (si no está ya abierto).

Si ya está abierto, también puede seleccionar la pestaña aparece justo encima del área de edición. Usted puede seleccionar cualquier archivo que está abierto para la edición seleccionando el su ficha.

Puede trabajar con el código XML directamente para definir donde todos los botones y el texto va y luego usted aprenderá lo menos cómo editar cuando las cosas van mal o para afinar, pero - Android Studio proporciona un muy buen editor interactivo y esto es digno de usar.

A medida que se experimentó la idea de cambiar entre una vista de diseño y una vista XML se convertirá en una segunda naturaleza. Piense en el editor interactivo como una forma muy fácil de generar el XML que de lo contrario tomaría las edades para hacerlo bien.

Si nos fijamos en la parte inferior izquierda verá dos pestañas - Diseño y texto:

Se puede cambiar entre la edición del XML como texto y editarlo en el diseñador de arrastrar y soltar, simplemente haciendo clic en la pestaña.

Si ahora hace clic en la pestaña de la ventana mostrará el diseñador pero sea paciente la primera vez que hace esto puede tardar unos instantes.

El diseñador se ve un poco demasiado para tomar en la primera vez que lo ve, pero usted se acostumbrará rápidamente a ella.

A la izquierda es una paleta de todos los componentes - botones, texto, casillas de verificación y así sucesivamente - que se puede colocar en la superficie de diseño.

En el medio está la superficie de diseño y el valor predeterminado es el tamaño de la pantalla y el aspecto del Nexus 4. Puede seleccionar otros dispositivos para trabajar.

A la derecha tienes el Árbol de componentes que muestra la estructura de su diseño, es decir cómo los diferentes componentes de interfaz de usuario están contenidas dentro de otros - es la misma que la estructura de anidación del archivo XML. Puede utilizar el Árbol de componentes para seleccionar componentes individuales de interfaz de usuario haciendo clic en sus nombres. También puede seleccionar los componentes de la superficie de diseño, pero algunas veces es más fácil utilizar el árbol de componentes.

Debajo del árbol de componentes que tiene la ventana Propiedades que se puede utilizar para establecer las propiedades, como la anchura, la altura, el color ... de cualquier componente en el diseño.

Si usted ha utilizado cualquier diseñador de arrastrar y soltar entonces éste será familiar para usted. Si ha tenido problemas con el diseño detallado utilizando un lenguaje de marcas ya sea HTML, XAML o XML, entonces te gusta lo fácil que el diseñador hace que la construcción y prueba de un interfaz de usuario.

En el caso de nuestro programa de ejemplo el único componente utiliza es una sola TextView que ya contiene el texto "Hello World". Un TextView es el componente estándar que utilizamos cuando todo lo que queremos hacer es mostrar un poco de texto estático.

Usted puede modificar el texto de saludo si quieres. Seleccione el componente TextView ya sea en la imagen del Nexus 4 o en el árbol de componentes y utilizar la ventana Propiedades para encontrar su propiedad Text. Cambiar esto a leer "Hola Android Mundial".

Alternativamente, usted puede simplemente hacer doble clic en la Vista de Texto y escriba "Hello Android Mundial" directamente en el cuadro de diálogo que aparece, - a menudo se pueden cambiar las propiedades principales de un objeto haciendo doble clic. Si cambia de esta manera usted también tendrá que proporcionar una identificación para el componente de lo contrario se genera un error. Esto es un error / característica y probablemente será fijado en versiones posteriores de Android Studio.

No te preocupes por la forma de la entrada original en el TextView comenzando con una @ y mirando complicado simplemente escriba la cadena en lo dado. La entrada por defecto hace referencia a un recurso de cadena predefinida - algo que podemos ignorar por el momento, junto con la advertencia de que las banderas Android Studio para decirle uso que estamos siendo travieso y no mediante una cadena de recursos. Es cierto, siempre es mejor definir las cuerdas que utiliza como recurso en lugar de incorporar directamente en su aplicación.

Puede utilizar el diseñador para crear cualquier interfaz de usuario es que quiere y que realmente no tienen que involucrarse en el XML que se corresponde con el diseño.

El diseñador generará automáticamente el código XML necesario para crear el diseño para usted y modificarlo a medida que cambia el diseño. Si realmente quieres ver el XML entonces todo lo que tienes que hacer es seleccionar la pestaña de texto en la parte inferior de la ventana de diseño.

<RelativeLayout xmlns:android= "http://schemas.android.com /apk/res/android" xmlns:tools="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" tools:context=".MainActivity"> 

<TextView android:text="Hello Android World" android:layout_width="wrap_content" android:layout_height="wrap_content" /> </RelativeLayout>

Usted debe encontrar que es bastante fácil de entender - leer el <TextView> etiqueta por ejemplo - pero dejar que el diseñador para crear y modificarlo. Las cantidades que empiezan por @ son todas las referencias a cosas definidas en otras partes de los archivos de recursos.

Vamos a volver al diseñador y el XML que genera más tarde.

El Java

Si hace doble clic en el archivo MainActivity.java, o simplemente seleccione la ficha MainActivity.java, verá el código que contiene.

Parte del código podría escondido pero se puede inspeccionar si desea haciendo clic en los botones + para expandirla.

La parte importante del código es:

public class MainActivity extends ActionBarActivity{ @Override protected void onCreate( Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); }

Hay otras dos funciones debajo de la función onCreate pero ignoran estos por el momento - que implementan características que realmente no pidas - útil pero no cuando acaba de empezar.

La función onCreate es la única cosa que importa en este momento.

La función onCreate se llama cuando se ejecuta su aplicación y se espera para crear la vista y hacer lo que sea la actividad se ocupa.

A medida que nuestra actividad en realidad no hacer nada más que lo único onCreate tiene que hacer es llamar primero al método heredado OnCreate decir super.onCreate para hacer todas las cosas normales y luego usar la función setContentView para seleccionar el archivo XML que determina la disposición de las actividades de la pantalla.

La línea:

setContentView(R.layout.activity_main);

es el más importante de todos y realmente el único que realmente hace nada. Se obtiene el objeto recurso que representa la disposición según lo definido por el archivo XML creado por el diseñador y la convierte en la ContentView actual es decir, es lo que se muestra en la pantalla.

Es decir que hace la conexión entre el diseño que hayas definido con el diseñador y se almacena en el archivo XML y la interfaz de usuario que aparece en la pantalla de los dispositivos.

Tenemos mucho que aprender sobre el objeto de recurso R pero se puede ver que su función principal es la de formar un vínculo entre su código de Java y los recursos que se han creado como archivos XML por el diseñador entre otros.

Como se trata de toda nuestra actividad hace esto es todo el código que necesitamos.

Aunque estoy de acuerdo que es apenas una "actividad" es suficiente para ver el esquema básico de una aplicación para Android y para ver cómo ponerlo en marcha - que es nuestro próximo trabajo.

Primeros pasos con el emulador

Hay dos formas distintas de funcionamiento de una aplicación para Android usando Android Studio.

Puede usar el emulador o en un dispositivo Android real.

Finalmente se tiene que descubrir cómo ejecutar una aplicación en un dispositivo Android conectado real porque el emulador sólo le permite probar un subconjunto de las cosas y es lento.

Sin embargo, por el momento el funcionamiento de su primera aplicación en un emulador es más que suficiente para empezar.

Todo lo que tienes que hacer es hacer clic en el icono de pista verde en la barra de herramientas superior - o bien utiliza el Run, Run "aplicación" del menú.

Al hacer esto, por primera vez se tardará un tiempo para que la aplicación para ser compilado. Carreras posteriores son más rápidas.

Cuando su aplicación se compila y listo para hacer verá un cuadro de diálogo aparece que le permite seleccionar un emulador de correr o iniciar uno va. Al instalar Android estudio se obtiene un emulador por defecto - un Nexus 5 corriendo KitKat - y usted puede simplemente seleccione emulador de lanzamiento y haga clic en Aceptar para ponerlo en marcha.Si usted necesita otros dispositivos que puede usar el Administrador de AVD definirlos - un tema que volverá a.

Por lo general, tarda bastante tiempo para la AVD para empezar porque no sólo tiene que inicializar el emulador también tiene que arrancar Android al igual que un dispositivo real. También hay unos momentos donde nada parece estar sucediendo. No entre en pánico, algo va a pasar con el tiempo. Usted puede monitorear la carga de la emulación en la ventana Ejecutar que aparece automáticamente en la parte inferior de Android Studio.

Sin embargo, toma mucho tiempo para empezar. Sin embargo, sólo tienes que hacer esto una vez por sesión de depuración porque la AVD puede ser reutilizado y la aplicación vuelve a cargar cada vez que haga algún cambio, y esto es una operación bastante rápida. La mayoría de los programadores de Android entrar en el hábito de comenzar una AVD, cuando comienzan a usar Android Studio para que esté listo para la prueba cada vez que el programa es.

Por último, recuerde que debe esperar hasta que el sistema operativo Android es cargado y se ve la pantalla de inicio familiarizado antes de empezar a preguntarse donde su aplicación es. Incluso cuando está cargado, es una buena idea para darle un par de segundos para Android Studio para notarlo y cargar su aplicación. Como el emulador es un dispositivo Android completa, también es necesario para desbloquearlo. Mientras que usted ha sido lo suficientemente paciente debe consultar a su aplicación.

En nuestro caso esto no es particularmente impresionante - sólo las palabras Hola Android World - pero cuando se piensa en el viaje viajaron en realidad debería impresionar.

A partir de este punto usted puede ahora modificar el código o el diseño y ejecutar la aplicación de nuevo para ver los efectos de los cambios. Con suerte usted no debería tener que cargar el emulador de nuevo. Si algo sale mal y se obtiene un lío entonces simplemente eliminar el proyecto y crear a partir de cero de nuevo.

Usted todavía tiene mucho por descubrir acerca de cómo extender la aplicación y hacer que sea útil, pero - la aventura ha comenzado.

Resumen

Android Estudio facilita la creación de aplicaciones de Android mucho más fácil que otros enfoques y desde el lanzamiento de la versión 1.0 es la única forma oficial para hacer el trabajo. 

Una aplicación tiene al menos una actividad y esto define un diseño de la pantalla y un comportamiento.Una actividad no tiene que tener una interfaz de usuario, pero en encajonado sí tiene uno.

Para crear una aplicación simple uso de la plantilla Actividad en blanco sin extras seleccionados.

El diseño de la pantalla es controlada por un archivo de formato XML, Main_Activity.xml en nuestro caso almacena en el directorio res. 

Android Studio proporciona un diseñador de arrastrar y soltar que le permite crear una interfaz de usuario sin tener que trabajar directamente con theXML. 

El comportamiento de la aplicación es controlada por un archivo Java, MainActivity.java en nuestro caso almacena en el directorio java. Puede editar el código en el archivo Java directamente en Android Studio. El Java tiene que cargar y mostrar el trazado definido en el archivo XML. 

Para ejecutar una aplicación que necesita ya sea una AVD basado emulador o un dispositivo Android real conectada a la máquina. 

Al ejecutar la aplicación se puede seleccionar qué AVD o dispositivo de hardware que se utiliza para probarlo.Al empezar sólo tiene que utilizar el valor por defecto AVD un Nexus 5.

1. Usted puede modificar y volver a ejecutar su aplicación sin tener que reiniciar el AVD o cualquier hardware real conectada a la máquina. 

2. La actividad y el interfaz de usuario

Así que ya sabes cómo crear una aplicación para Android, pero ¿realmente sabes cómo funciona? En esta segunda parte de nuestro libro electrónico sobre cómo empezar con Android usando Android Estudio miramos cómo crear una interfaz de usuario y cómo conectarlo a el Codigo de la Actividad. 

Descubrimos en el capítulo 1 cómo utilizar Android Estudio de Google Android IDE, para construir la aplicación más sencilla posible.

En el camino descubrimos que una aplicación para Android se compone de dos partes - una actividad y una vista.

La actividad es el código Java que hace algo y el View proporciona la interfaz de usuario (UI).

Usted puede pensar en esta dualidad como algo similar a la página HTML y el JavaScript que se ejecuta para que haga algo, o como una forma de XAML y el código subyacente.

La idea clave es que una actividad es el código que funciona con una pantalla de interfaz de usuario definido por la vista.Esto no es del todo exacto en que una actividad puede cambiar su punto de vista para que un trozo de código Java puede apoyar una serie de puntos de vista diferentes. Sin embargo, hay ventajas de utilizar una actividad por visión, ya que, por ejemplo, esto cómo el Android botón atrás navega su aplicación - de una actividad a.

Una aplicación compleja, casi siempre consiste en múltiples actividades que el usuario puede moverse entre las páginas web como una aplicación sencilla pero puede manejar bastante bien con una sola actividad.

No hay una regla fija en cuanto a cuántas actividades de su aplicación tiene que tener - pero tiene que tener por lo menos uno.

Si usted se está preguntando si una actividad puede existir sin un juicio, la respuesta es que se puede, pero no tiene mucho sentido, ya que esto dejaría al usuario y no hay forma de interactuar con la aplicación. Las actividades son activas cuando su vista se presenta al usuario.

Realmente es una gran simplificación de pensar en términos de una actividad que corresponde a una sola pantalla con una interfaz de usuario.

Si quieres algo para funcionar sin una interfaz de usuario a continuación, lo que quieres es un servicio o un proveedor de contenidos - más de lo que mucho más tarde.

También vale la pena dejar claro en esta primera etapa que una actividad tiene un solo hilo - el hilo de interfaz de usuario - y hay que tener cuidado de no realizar ninguna tarea larga porque entonces van a bloquear la interfaz de usuario y hacer que su aplicación parece congelarse. Es una actividad que sólo puede hacer una cosa a la vez que un esto incluye la interacción con el usuario.

Observe también que la creación de actividades adicionales no crea nuevos temas. Sólo una actividad está activo en un momento dado - más de esto más adelante si tenemos en cuenta el ciclo de vida Actividad en detalle.

En otras palabras, las actividades no son un sustituto para conocer enhebrar pero si acaba de empezar puede ignorar estos problemas por un tiempo.

Por el momento, vamos a concentrarnos en la única interfaz de usuario de pantalla Actividad porque es el bloque de construcción más comunes de aplicaciones que se encontrará y es incluso donde las aplicaciones más complejas empiezan desde.

El MainActivity

Hay por supuesto una actividad que ha sido designado como el que se lanzará cuando aplicación se inicia.

Si utiliza Android Studio para crear una nueva aplicación Actividad en blanco llamado SimpleButton y aceptar todos los valores predeterminados y luego la actividad de inicio se llama MainActivity por defecto.

Puede cambiar qué actividad se inicia la aplicación por el encadenamiento de una línea en el manifiesto de la aplicación. El Manifiesto es un archivo de proyecto que no hemos discutido antes, porque si usted está usando Android Studio mayoría puede ignorar pero es mejor si sabes que existe y lo que hace.

El Manifiesto se almacena en la aplicación / directorio se manifiesta y se llama AndroidManifest.xml. Es un archivo XML que indica al sistema Android todo lo que necesita saber acerca de su aplicación. En particular, se enumeran todas las actividades y cuál es la de utilizar para iniciar las aplicaciones.

Si abre el Manifiesto generado, simplemente haga doble clic en él, verá un poco más abajo en el archivo:

<activity android:name=".MainActivity" android:label="SimpleButton" >

Esto define la actividad del sistema ha creado para usted y las líneas justo debajo de este:

<intent-filter> <action android:name= "android.intent.action.MAIN" /> <category android:name= "android.intent.category.LAUNCHER" /> </intent-filter> </activity>

Definirla como la actividad de inicio. Aviso de que la actividad se inicia la aplicación no tiene nada que ver con lo que usted le llama es decir, llamándolo MainActivity no es suficiente.

Para el momento en que usted puede confiar en Android Studio para cuidar el Manifiesto para usted. En la mayoría de los casos, sólo tendrá que editar directamente cuando se necesita para corregir un error o añadir algo avanzado.

Dentro de la Actividad

La actividad generada tiene una MainActivity clase que contiene todos los métodos y propiedades de su actividad.También tiene tres métodos generados - onCreate, onCreateOptionsMenu y onOptionsItemSelected. Los dos últimos se obviamente conectado a la acción del menú Opciones y este es un tema importante, pero uno que puede ser ignorada

por el momento. No todas las actividades tienen que tener un menú Opciones y usted podría incluso eliminarlos.

El método más importante es definido onCreate.

Se trata de un controlador de eventos y se llama cuando se cree que la aplicación por primera vez. Este es el lugar que hacemos todas las inicializaciones y establecer para toda la aplicación. También es generalmente el lugar mostramos pantalla de interfaz de usuario principal de la aplicación.

Vamos a echar otro vistazo al código generado para onCreate:

@Override protected void onCreate( Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } 

El controlador de eventos onCreate se pasa un objeto Bundle llamado savedInstanceState. Con ello se pretende conservar la información de estado entre invocaciones de que APP y vamos a ver cómo se utiliza más adelante. En este caso no hay datos se ha guardado y así savedInstanceState es nulo - pero usted todavía tiene que pasarlo al método heredado onCreate.

La instrucción final llama setContentView que es un método que tiene un número de diferentes formas sobrecargados.

En este caso se pasa un entero que indica qué archivo XML describe el diseño que se utilizará para la vista. El método setContentView utiliza esto para crear todos los componentes de la interfaz de usuario que según se define en el archivo XML.

Vale la pena mirar un poco más de cerca la forma en que se especifica el archivo de diseño, porque se trata de un modo general que Android le permite acceder a los recursos.

El objeto R es construido por el sistema para reflejar los recursos que ha depositado en los directorios de recursos. En este caso R.layout.activity_main devuelve un valor entero que permite que el método setContentView para encontrar el archivo de diseño activity_main XML.

En general todos los recursos se encuentran a través del objeto R, piensa en él como un objeto de biblioteca de recursos.

Ver y ViewGroup

Ok hasta ahora tan bueno, pero es importante darse cuenta de que lo que sucede a continuación es que el archivo XML se representa como un conjunto de objetos de vista. Es decir objetos Java que son todas las subclases del objeto View.

Todo el sistema de interfaz de usuario y los gráficos se implementa como una jerarquía de componentes derivados de la clase View. Si ha utilizado casi cualquier marco GUI - AWT, Swing, XAML etc - entonces esta idea no será nuevo para usted.

Por ejemplo, un botón es una clase derivada de vista y para crear un botón todo lo que tienes que hacer es crear una instancia de la clase botón. Puede, por supuesto crear tantos botones como desee simplemente creando más instancias.

Esto deja abierta la pregunta de dónde está el botón aparece en el diseño?

La respuesta a esto es que no son objetos ViewGroup que actúan como contenedores para otros objetos de visualización. Puede ajustar la posición de los objetos de vista del niño o simplemente permitir que sean controladas por diversas normas de diseño - más de que más tarde.

Usted puede optar por crear toda la interfaz de usuario en código mediante la creación y el trabajo con las instancias de objetos de vista y esto es algo demostrado en un capítulo posterior UI Gráficos A Deep Dive .

.

Alternativamente, puede utilizar XML para definir objetos de vista y cómo encajar uno dentro de otro y se basan en el sistema para crear la jerarquía de vistas de objetos para usted.

La manera más simple sin embargo es utilizar el diseñador para crear el archivo XML y luego permitir que el sistema para crear los objetos para que a partir del archivo XML generado.

Ser capaz de trabajar con la interfaz de usuario en un editor interactivo es una de las grandes ventajas de usar Android Estudio e incluso si usted sabe cómo editar el archivo de diseño XML directamente no es una característica que debe renunciar a la ligera. Es casi siempre una buena idea utilizar el editor de formato en un primer momento y aplicar ningún ajuste, si es necesario para el archivo XML después.

Creación de una interfaz de usuario

Para ver cómo todo esto encaja permite añadir un botón y un texto

Primero quite el texto Hola Mundo que se genera automáticamente cuando se crea una nueva actividad en blanco. Sólo tiene que cargar el archivo activity_main.XML abriéndolo.

Verá el diseñador y puede seleccionar el texto haciendo clic sobre ella y borrar el texto pulsando delete.

Observe que hay un comando deshacer si elimina algo por error.

A continuación, seleccione el botón de la sección Widgets de la paleta haciendo clic en ella:

Si ahora movemos el cursor sobre el área de diseño usted descubrirá que al mover varias alineaciones se indican junto con la información de posicionamiento.

Para colocar el botón, haga clic en un botón y completo con el título predeterminado aparecerá Nuevo botón.

Ahora usted tiene un botón en la interfaz de usuario listo para ir vamos a añadir un Texto grande Widget exactamente de la misma manera - haga clic en él en la paleta, la posición en el diseñador y haga clic para establecer la posición. Tenga en cuenta que Android Studio proporciona información de posicionamiento para ayudarle a alinear los componentes de la interfaz de usuario.

Eso es todo y sí la creación de una interfaz de usuario completo complejo es simplemente más de lo mismo. Elija componentes de la Paleta y la posición sobre la superficie de diseño.

Si usted se está preguntando lo que el icono de la bombilla se trata entonces es de destacar en esta primera etapa que Android estudio intenta ayudar en todo lo que puede. La bombilla de la luz significa que hay algún tema que le gustaría tratar. Si hace clic en el icono, verá una lista de los problemas reales o potenciales. En este caso el problema es que estamos usando una cadena en el cuadro de texto y de buenas prácticas es que debemos usar un recurso. Hasta que encontremos más sobre los recursos puede ignorar este gentil advertencia.

Si ahora ejecuta el programa, haga clic en el icono de la pista verde y en el capítulo 1, si usted no sabe cómo hacer esto, usted podrá ver su nueva interfaz de usuario.

Por supuesto que no hace nada, incluso si usted puede hacer clic en el botón. El botón haga click pero no hay un código conectada al evento click del botón de decir lo que debería suceder - algo que trataremos en breve.

Propiedades

Nuestra próxima tarea es cambiar el título en el botón.

Usted debe saber que los objetos tienen propiedades y métodos.

Cosas como texto del título, color de fondo y así sucesivamente para los widgets de interfaz de usuario se representan como propiedades.

Puede cambiar las propiedades en clave o en tiempo de diseño se puede utilizar la ventana Propiedades en la parte derecha de la pantalla. Si selecciona el botón y desplácese hacia abajo en la ventana de propiedades es muy probable que encontrar la propiedad text del botón. Este contiene actualmente el valor "Nuevo botón". Si cambia esto a "Click Me" y volver a ejecutar la aplicación, verá que el título ha cambiado.

Puede establecer las propiedades iniciales de cualquiera de los widgets que usted ha puesto en la interfaz de usuario. Hay un gran número de propiedades y tenemos que pasar algún tiempo mirando a algunos de ellos. Sin embargo, por el momento lo importante es que usted verá lo fácil que es cambiar una propiedad mediante la ventana de Propiedades.

Como se puede adivinar, la propiedad que ha cambiado como resultado un cambio en el archivo XML que define la disposición. El principio general es que el diseñador crea el archivo XML que se podría haber creado a mano, sin ninguna ayuda del diseñador. En este sentido, el diseñador no añade nada al proceso, aparte de ser mucho más fácil.

Como consejo, si hace doble clic en un widget a continuación se le presentará un cuadro de diálogo que le permite examinar y modificar las propiedades del texto y Identificación del widget en cuestión.

Tenga cuidado porque hay una "característica" en Android Studio versión 1 que da lugar a un componente que no tiene un identificador que se asigna un identificador nulo si se hace doble clic y luego no introduce una cadena de identificación.Si esto sucede, usted recibirá un mensaje de error cuando se ejecuta el programa y la única forma de corregir el problema es editar el archivo XML y quitar el <android: id> completamente. Es de suponer que un día esta será fijo.

Eventos

Ahora queremos hacer algo cuando se hace clic en el botón.

Android es compatible con un sistema orientado a eventos completa. Así que lo que tenemos que hacer ahora es definir un método que se llama cuando se hace clic en el botón.

Si usted está familiarizado con otros idiomas que podrían encontrar la manera de trabajar con Java extraños sucesos y enrevesados. Es y vamos a tener que volver a descubrir la historia completa de cómo los eventos se implementan después.

Hay un número de diferentes formas de especificar un controlador de eventos pero la más sencilla es utilizar el diseñador para generar el XML necesario para el sistema de transmisión en circuito del controlador de eventos para el evento. Este no es un método que se puede utilizar todo el tiempo, sólo funciona para el evento click, pero le ayudará a comenzar.

Utilizando los controladores de eventos diseñador enfoque método Click se métodos simplemente público de la actividad actual con la firma:

method( View v)

Usted puede llamar al método todo lo que quieras, pero en la mayoría de los casos, le ayuda a especificar exactamente lo que el caso se maneja es. En este caso queremos manejar evento onClick del botón - que se produce cuando el usuario hace clic en el botón con un ratón o más probablemente grifos en el botón utilizando un dispositivo sensible al tacto.

Cargue el archivo MainActivity.java en el editor de código y añadir el siguiente método:

public void buttonOnClick(View v) { // do something when the button is clicked }

Esto necesita ser añadido directamente siguiendo el método onCreate o en cualquier lugar que lo convierte en un método de la clase MainActivity.

Cuando entras en este método en el código es casi seguro que notar una que Vista se muestra en rojo y cuando se pasa sobre la palabra, verá un mensaje de error: No se puede resolver Symbol View. Esto es porque cualquier clase utiliza que no se define dentro del mismo archivo, y esto significa que la mayoría de ellos, necesita una declaración de importación. Las importaciones están agrupados en la parte superior del programa y lo que hay que añadir es la línea:

import android.view.View;

Siempre se puede añadir una sentencia import manualmente pero Android Estudio tiene un mecanismo general para la fijación de simples omisiones y errores. Todo lo que tienes que hacer es la posición del cursor en la palabra que se muestra en rojo y presione Alt + Enter. Esto soluciona el problema, ya sea, en cuyo caso la palabra cambia de rojo a su color normal o que le ofrece una lista de alternativas que fijan el problema para que usted pueda elegir.

La cosa más importante a saber es que cuando ves una palabra en rojo - entonces no es un problema que debe arreglar de forma manual o con la ayuda de Android Studio.

Cuando se utiliza una clase en su programa tiene que ser importado.

Con todo este código fuera del camino si ahora cambia de nuevo al diseñador y seleccionar el botón. Desplácese hacia abajo en la ventana de la propiedad hasta que vea la propiedad onClick. Si ahora hace clic en la flecha hacia abajo para ver la lista desplegable de opciones posibles bajo control, debería verte método buttonOnClick:

Alternativamente, usted puede simplemente escriba el nombre del controlador de eventos como el valor de las propiedades.Observe que no escribe en los parámetros sólo el nombre del método.

Eso es todo lo que hay que hacer - definir el controlador de eventos con la firma correcta y establezca la propiedad onClick apropiado en la ventana de propiedades.

Cuando se trata de otro tipo de evento que usted tiene que hacer el trabajo en el código - el método XML / diseñador sólo funciona para onClick.

Conexión de la Actividad de la interfaz de usuario

Ahora tenemos un controlador de eventos enganchado hasta el evento click botón que normalmente queremos hacer algo que afecta a la interfaz de usuario como resultado.

Supongamos que cuando se hace clic en el botón que queremos cambiar el texto que aparece en el widget de texto grande a "usted me hizo clic!".

Podemos hacer esto cambiando la propiedad text del widget de texto grande al nuevo texto. El único problema es cómo encontramos y referencia el widget de texto grande en el código?

Este es un problema bastante común cuando se utiliza un lenguaje de marcado para definir una interfaz de usuario. El lenguaje de marcado define los widgets u otros objetos de interfaz de usuario y el código tiene que tener una manera de hacer la conexión a aquellos objetos de interfaz de usuario.Por ejemplo en JavaScript que haga uso del método getElementById para recuperar un objeto DOM correspondiente a un elemento HTML en particular.

En Android hacemos algo similar.

En primer lugar, asegúrese de seguir la idea de que todo el XML generado por el diseñador consigue convertido en un conjunto de objetos de Java, uno para cada widget y únete colocado en la superficie de diseño. Estos objetos tienen el mismo rango de propiedades como se vio en la ventana y métodos Propiedades para hacer otras cosas.

Todo lo que necesitas hacer si encontrar una manera de hacer referencia a uno de ellos.

En el caso del objeto View que causó el evento esto es muy fácil, ya que se pasa al controlador de eventos como el único argumento de la llamada. Así que si el controlador de eventos es:

public void buttonOnClick(View v) {

y el controlador de eventos sólo se engancha hasta el botón entonces usted puede estar 100% seguro de que v es el objeto de botón cuando se produce el evento.

Si desea cambiar el título del botón usted podría utilizar su método setText para cambiar su valor.

Nota: si usted no está acostumbrado a Java entonces vale la pena señalar que en general todos los marcos de Java siguen la regla de que si un objeto tiene una propiedad llamada myProperty, visible como tal en la ventana de la propiedad luego de código configurarlo usando setMyProperty y recuperarla usando getMyProperty.

Así que todo lo que tiene que escribir, en principio, es:

v.setText("I've Been Clicked!");

pero esto no funciona porque v se declara como un objeto de vista general que no tiene un método setText - no todos Ver objetos tienen texto para ajustar.

Para llamar al método setText de Button tenemos que desechar V de su tipo correcto - un botón.

Nota: casting es donde usted le dice al sistema del tipo de objeto que se está trabajando. Si ClassB es una subclase de classA entonces usted puede tratar a un objeto ClassB como classA - después de todo lo que tiene todos los métodos y propiedades que classA hace por herencia. Sin embargo, si usted desea hacer uso de una propiedad o un método que sólo ClassB tiene entonces usted necesita para lanzar la referencia al objeto ClassB para hacer su tipo claro.

Por ejemplo. asumiendo ClassB hereda de classA:

classA myObject = new classB();

crea una instancia de ClassB pero miObjeto se declara de tipo classA. Esto está bien pero sólo se puede acceder a los métodos y propiedades del objeto classA. Pero si intentas

myObject.classBMethod();

a continuación, se producirá un error si classBMethod sólo existe en ClassB. Para utilizar el método ClassB tienes que echar miObjeto a su tipo real:

(classB) myObject

Puede almacenar una referencia al elenco de una nueva variable:

classB myClassBObject = (classB) myObject;

y luego llamar al método

myClassBObject.classBMethod();

o simplemente puede hacer el molde sobre la marcha a costa de un par extra de paréntesis:

((classB) myObject).classBMethod();

Sin embargo, si usted utiliza simplemente añadir el elenco a Button usted descubrirá que las banderas Android Studio un error al mostrar Button en rojo. Ustedes han visto una vez antes la primera vez que utilizó la clase View. En este caso tiene dos usos de un nuevo botón de clase sin importarlo.

Si nos fijamos en el mensaje indicio que sugiere pulsando Alt + Enter, que siempre es un buen consejo, ya que produce una lista de posibles soluciones para el problema. En este caso hay que añadir la definición de clase al inicio del programa.

import android.widget.Button;

Usted puede hacer esto de forma manual, es decir, usted puede escribirlo, o simplemente presione Alt + Enter para aceptar la sugerencia.

Si pasa el ratón sobre el nombre de la clase Button corregido también verá una bombilla. Si hace clic en este que ofrecerá a partir la declaración y la asignación por ser mejor estilo.Android estudio está lleno de consejos y ofertas para hacer que el código mejor a cada paso - usted no tiene que aceptarlas.

Por el momento vamos a seguir con la línea única.

Button button=(Button) v;

Ahora tenemos el objeto de botón podemos llamar a su método setText:

button.setText("I've Been Clicked!");

El controlador de eventos completa es:

public void buttonOnClick(View v) { Button button=(Button) v; button.setText("I've Been Clicked!"); }

Ahora bien, si se ejecuta el programa, verá el cambio el título del botón cuando se hace clic en el botón.

Observe que este método sólo funciona si se conoce el tipo de objeto que causó el evento y llama al controlador de eventos. Si su controlador de eventos sólo se conecta a un solo widget de entonces usted sabe el tipo del objeto que causó el evento.

Ahora supongamos que queremos hacer algo para uno de los otros widgets en la vista. En este caso tenemos que encontrar el objeto que representa el widget sin la ayuda de la argumentación del controlador de eventos.

Por ejemplo, ¿cómo encontrar el TextView que colocamos debajo del botón?

En el controlador de eventos del botón es el objeto que causó el evento suceda por lo que ya se encuentra pero ¿cómo encontrar otro widget en el diseño?

Este es un patrón muy estándar en el trabajo con objetos de vista de la actividad. Primero usted hace uso del objeto R encontrar Identificación del widget. En este caso la TextView se ha dado el TextView Identificación por defecto, así que podemos utilizar:

R.id.textView:

y este devuelve un entero único que identifica el widget.

A continuación, utilizamos las Actividades

findViewById(int)

método que tiene el ID de número entero y devuelve el objeto Java correspondiente a Identificación.

Por supuesto, esto se devuelve como un objeto View porque findViewById no conoce el tipo de objeto que devuelve más precisión. Así que tenemos que echar a hacer uso del objeto TextView.

Reuniendo todo esto da:

TextView myTextView=(TextView) findViewById(R.id.textView);

Una vez más Android Studio quejarse TextView y si pulsa Alt + Enter se agregará la importación de clases al inicio del programa para usted:

import android.widget.TextView; 

Ahora que tiene el objeto TextView se puede utilizar el método setText para cambiar lo que se muestra:

myTextView.setText("You Clicked My Button!");

El controlador de eventos completa es:

public void buttonOnClick(View v) { Button button=(Button) v; button.setText("I've Been Clicked!"); TextView myTextView=(TextView) findViewById(R.id.textView); myTextView.setText("You Clicked My Button!"); }

Si ahora ejecuta el programa, verá que se le informa de dos veces el hecho de que este botón muy importante ha hecho click en:

Usted puede pensar que todo esto es un material muy pequeño y nada como una aplicación real, pero así es como construir una interfaz de usuario funciona en Android.

Ahora ya sabe cómo diseñar una sola aplicación la pantalla utilizando los widgets disponibles en la caja de herramientas de diseño y la forma de conectarlos para manejar sus eventos de clic, encontrar el objeto Java que los representa y cómo llamar a métodos que las modifican.

Aparte de los detalles finos de cómo cada uno de los widgets de obras - botones de opción, casillas de verificación y así sucesivamente usted ahora tiene el esquema general de cómo construir una sola aplicación pantalla.

Resumen

Una actividad es la unidad de la aplicación para Android y que corresponde aproximadamente a una pantalla completa de la interfaz de usuario más el código para que funcione. 

En la mayoría de los casos va a crear una actividad para cada pantalla de interfaz de usuario que desea presentar a su usuario. 

Sólo una Actividad de que aplicación se está ejecutando en un momento dado. 

Una actividad es un solo subproceso y se ejecuta en el hilo de interfaz de usuario. 

Se puede establecer que la actividad se inicia la aplicación en el Manifiesto - Android Estudio establece este a MainActivity por defecto. 

La actividad tiene eventos correspondientes a las diferentes etapas del ciclo de vida en ella. El evento onCreate se llama cuando la aplicación inicia por primera vez y es aquí donde se realiza toda la inicialización. 

También puede restaurar el estado aplicaciones de ejecuciones anteriores en este punto. 

La Actividad continuación, carga una vista o ViewGroup objeto para crear la interfaz de usuario. 

Puede crear objetos Vista / ViewGroup de tres maneras posibles: en el código, usando XML o utilizar el diseñador para generar el código XML. 

El diseñador es mucho, la forma más fácil de crear una interfaz de usuario. 

Al abrir el archivo XML que puede utilizar el diseñador para colocar los widgets correspondientes para ver objetos en la superficie de diseño. 

Puede utilizar la ventana de propiedades para establecer las propiedades de cada widget. 

El archivo XML que crea el diseñador es utilizado por la actividad para establecer su interfaz de usuario mediante la creación de objetos Java que corresponden a cada uno de los objetos View colocados mediante el diseñador. 

Cuando hace referencia a una clase que no está definido en el archivo, es decir, la mayoría de ellos, entonces usted necesita para añadir una sentencia import al principio del código. 

Si utiliza Alt + Enter cuando el cursor se encuentra dentro de cualquier palabra que se muestra en rojo a continuación Android estudio ayudará a solucionar el problema. 

Puede conectar los controladores de eventos onClick definidos dentro de la actividad actual de los widgets de la ventana de propiedades. 

Un controlador de eventos onClick es sólo una función pública con la firma MyEventHandler (Ver v) 

El parámetro Ver objeto se envía al objeto vista que provocó el evento. Esto se puede utilizar para acceder a las propiedades / métodos del objeto View que el usuario con el que tratamos. 

Para acceder a otros Objetos de visión sigue el patrón estándar de:

1.

1. Encuentra el id entero a través del string id, situado en el diseñador, del objeto de recurso widget de usar R.id.stringId.

2. Utilice la Identificación del número entero para recuperar el objeto Java correspondiente al widget usando findViewById (int Id)

3. Trabajar con métodos / propiedades del objeto para modificarlo. 

3. Aventuras Android - la construcción de la interfaz de usuario

Si usted ha estado leyendo las aventuras de Android, en este punto a entender cómo la actividad y el Vista se unen para crear una aplicación sencilla, pero la interfaz de usuario de Android es más complicada que la mayoría debido a su necesidad de hacer frente a una serie de muy diferente pantalla tamaños y orientaciones. En este capítulo, ahora se actualiza a Android Studio Version 1.0, nos fijamos en el problema de la disposición y el trabajo con el marco de interfaz de usuario. En la forma en que construimos una aplicación de calculadora.

Cuando la construcción de una aplicación para Android que te va a pasar mucho más tiempo de lo que puedas imaginar en el perfeccionamiento de la interfaz de usuario - la interfaz de usuario. Por eso es importante que usted domina los conceptos básicos para que pueda pasar al código que hace las cosas más interesantes.

La curva de aprendizaje con cualquier marco de interfaz de usuario es más o menos lo mismo.

Primero tienes que saber lo que constituye una aplicación que puede ejecutar es decir, cuando es el código?

En el caso de Android se trata de una actividad.

Usted tiene que averiguar cómo se representan los componentes de interfaz de usuario, cómo puede crearlas y cómo conectar la interfaz de usuario con el código.

En el caso de Android este es un asunto de una jerarquía de objetos de vista y conectar con el código es una cuestión de encontrar los objetos que representan cada componente de interfaz de usuario y la adición de controladores de eventos.

Una vez que tenga los elementos básicos que tienen que empezar a explorar los componentes que se le ha suministrado para construir una interfaz de usuario.

En general, esto puede variar en el extremadamente simple - el botón por ejemplo - para aplicaciones casi completos en sí mismos - el Listview por ejemplo. Se necesitaría mucho tiempo para dominar todos ellos, pero lo que la mayoría de los programadores hacer es asegurarse de que pueden utilizar los componentes básicos y luego averiguar acerca de los componentes más sofisticados más grandes cuando sea necesario.

La buena noticia es que una vez que sabes cómo uno de los componentes, incluso el más simple, funciona entonces la mayor parte de ella generalizada a mayores cosas más complicadas.

También tenemos que preocuparse de cómo el diseño de la interfaz de usuario - como el tamaño y la posición y conjuntos de componentes.

Android es particularmente sofisticado en este sentido porque al ser un sistema operativo móvil que tiene que lidiar con una amplia gama de tamaños de pantalla e incluso cambios de orientación, mientras que una aplicación se está ejecutando.

Esto no es un simple temas y vamos a tener que considerar con más detalle más adelante, pero por el momento sólo vamos a echar un vistazo a los aspectos más fáciles de diseño de la pantalla.

Explorando El Diseñador

Como ya se ha explicado, hay tres formas de crear una interfaz de usuario.

1. Puede crear todos los objetos de vista en código

2. Puede crear un archivo XML, además el sistema convertirlo en objetos en tiempo de ejecución o

3. puede utilizar el Diseñador para crear interactivamente el archivo XML.

En muchos sentidos, 2 y 3 son el mismo enfoque es sólo un cambio en cómo se crea el archivo XML.

Si está usando Android Estudio continuación, utilizando el Diseñador es la forma más simple y más productivo trabajar así que vamos a concentrarnos en este método de crear una interfaz de usuario.

Una sencilla interfaz de usuarioIniciar Android Studio y crear un nuevo proyecto simple actividad blanco llamado UItest - esto va a ser nuestro patio interfaz de usuario para el resto del capítulo. Acepte todos los valores predeterminados y esperar mientras se crea el proyecto.

Si abres la función activity_main.xml archivo en la carpeta app / res / layout entonces el Diseñador se abrirá y usted verá la prestación familiar del diseño por defecto.

Ahora es el momento de mirar a la paleta con más detalle.

Los tres principales secciones de la paleta de mantener los componentes más importantes de la interfaz de usuario.

1. Los diseños son contenedores para otros componentes que proporcionan diferentes reglas de diseño. Layouts son algo que se utiliza una vez por Actividad por lo que probablemente no deberían estar en la parte superior de la lista. 

2. La sección Widgets contiene los más frecuentemente utilizados componentes - Botones, TextViews, casillas de verificación y así sucesivamente. Este es el conjunto de componentes que necesita para aprender a usar primero. 

3. La tercera sección - campos de texto son un conjunto de componentes de entrada de texto que todo el trabajo en más o menos la misma manera.

El Botón - En Profundidad

¿Dónde más deberíamos empezar - el Botón es casi el "Hola Mundo" de la construcción de la interfaz de usuario.

Si usted sabe cómo trabajar con un botón usted está bien en su camino a la comprensión de todos los componentes posibles.

La buena noticia es que ya hemos conocido y utilizado el botón en el Capítulo 2 y descubrió cómo trabajar con él en el código.

Sin embargo todavía hay mucho que descubrir.

Generalmente hay tres cosas que hay que descubrir sobre el uso de cualquiera de los componentes.

1. Cómo hacer que un principio parezca que lo desee. Se trata de una cuestión de descubrir y configuración de propiedades mediante el Diseñador.

2. Cómo modificar la forma en que un componente se ve en tiempo de ejecución. Esta es una cuestión de encontrar la manera de trabajar con propiedades en código. y finalmente

3. Cómo conectar los eventos generados por el componente con el código.

Configuración de las propiedades suena fácil pero hay diferentes tipos de propiedades y estos tienen diferentes formas adecuadas de que le permite interactuar con ellos.

Lo primero que tenemos que saber es cómo posicionar un componente.

Posicionamiento relativo

Antes de continuar con el proyecto de seleccionar y eliminar el defecto "hola mundo" texto - que hace que probar cosas más fácil tener una superficie de diseño limpio.

Luego haga clic en el botón de la paleta y observe la forma en que la información de diseño cambia a medida que se mueve el botón de vuelta de la superficie de diseño.

Al mover el botón a su alrededor aparecen varios mensajes a AlignParent y una medición del relleno aplicado al establecer la propiedad margen.

Se trata de cómo los componentes se colocan con el RelativeLayout defecto - más de lo que más adelante en este capítulo. Vale la pena decir que la RelativeLayout es el más sofisticado de los Layouts y no el que desea utilizar para diseños simples. En la mayoría de los casos no son mejores, más simple y más fácil de controlar que el Layouts RelativeLayout.

Sin embargo, es el diseño se obtiene de forma predeterminada y en muchos casos es más eficiente que las alternativas.

En este diseño los componentes están posicionados en relación con otros componentes. Al iniciar el único otro componente es el propio diseño y por lo que son esencialmente posiciona en relación a su - es decir, toda la pantalla.

El RelativeLayout sólo admite nueve posiciones diferentes para un componente:

Arriba - izquierda, centro y derecha

Centro - izquierda, centro y derecha

Abajo - izquierda, centro y derecha

Todos los componentes están colocados en una de estas nueve localidades sino proporcionar un posicionamiento más fino se puede especificar un desplazamiento en términos de un margen que se puede ver como las flechas verdes.

En otras palabras, usted está colocando los componentes en decir la parte superior izquierda de la pantalla, pero luego estableciendo un margen que puede mover el componente a la posición exacta que usted quiere. Esta combinación de una de las nueve posiciones fijas en el diseño, además de los márgenes de variación continua de trabajo en conjunto para que pueda colocar un componente en cualquier parte de la superficie de diseño.

Si juegas con el posicionamiento en el Diseñador obtendrá rápidamente la idea.

Como puede imaginar, hay propiedades que le permiten establecer la ubicación y márgenes para cada posición de manera manual.

Todas las propiedades de diseño comienzan con el diseño: nombre que el nombre da el posicionamiento efectuado.

Por ejemplo, si nos fijamos en la ventana Propiedades, verá:

layout:alignParent

que podría ser superior, izquierda, abajo o hacia la derecha.

y

layout:centerInParent

que puede ser horizontal, vertical o ambos

Se puede ver que una combinación de éstos, más

layout:margin

le da todas las posibilidades de posicionamiento que hemos visto en el Diseñador.

Tenga en cuenta que no todos los ajustes de estas propiedades tienen sentido - por ejemplo, diciendo que desea que el componente en la parte superior y centrado vertical no tiene sentido.

También vale la pena entender que, en lo que le permite ajustar la posición de un componente simplemente arrastrándolo a la ubicación que desee Diseñador está trabajando cómo configurar correctamente múltiples propiedades. Usted puede hacer esto manualmente para obtener el mismo efecto, pero el diseñador simplemente desde donde se ha colocado un componente.

Es por esto que es más fácil dejar que el diseñador establece las propiedades para usted.

Así que el posicionamiento en una disposición relativa es con respecto al recipiente - esto es sólo la primera opción.

Sin embargo, las cosas se ponen un poco más complicado, tan pronto como tengamos más de un botón, o en general cualquier componente, en el diseño. Si hace clic para colocar un segundo botón y luego mover la ubicación alrededor de la pantalla otra vez te darás cuenta de que ahora alineaciones se muestran por primera Button, así como los padres.

En una disposición relativa puede establecer la posición de un componente relativa al contenedor principal oa cualquiera de los otros componentes en el contenedor.

El Diseñador posiciona el dispositivo que está utilizando en relación con el componente más cercano o el contenedor principal.

Lo que esto significa es que si coloca un botón segundos con respecto al primer botón después el segundo se mueve si cambia la posición de la primera - probarlo para ver cómo funciona esto.

Lo que es menos obvio, pero lógico, es cualquiera de los componentes en posición relativa se moverán si el aspecto del componente que se posicionan en contra de movimiento.Por ejemplo, si un componente está posicionado en relación con el lado derecho de otro componente luego hacer el componente más amplio mueve el componente que está posicionado relativamente a ella.

Como puede imaginar hay un conjunto de propiedades que se pueden utilizar para colocar un componente en relación con otra distribución: alignComponent tiene pares de sub-propiedades que conectan dos componentes. Por ejemplo la parte superior: la parte superior da una posición relativa de la parte superior de uno de los componentes con la parte superior de otro, de manera similar a la izquierda: la derecha coloca el lado derecho de un componente en el lado izquierdo de otro. En cada caso, usted también tiene que proporcionar el texto Id del componente que debe ser alineada a.

Todo esto suena muy complicado y podría dejarte pensando que todo es innecesario.

Sin embargo esto significa que usted puede construir conjuntos de componentes alinearon todo a uno que está alineado con el recipiente de manera que todos se mueven juntos como un grupo. Esto significa que puede colocar un componente con un desplazamiento de otro sin importar el tamaño de la primera componente es. También puede configurar los componentes para alinearse con el lado izquierdo y derecho de la pantalla y permitir la rotación de vertical a horizontal.

No obstante todo esto, dijo que es muy fácil de conseguir en un completo desastre con la disposición relativa en el Diseñador. Si los componentes van a faltar, entonces es probable que se encuentran en la parte superior de uno al otro. La forma más fácil de solucionar este problema fuera es ir a la ventana Propiedades y restablecer manualmente una de las propiedades de posicionamiento.

Es bueno notar lo siguiente:

Utilice posicionamiento relativo a otro componente si tiene sentido lógico. Esto es, si usted tiene un componente de entrada de texto, entonces tiene sentido para colocar su botón de aceptar en relación a su lado derecho.

Si coloca todo lo relativo a los padres contenedor entonces usted tiene efectivamente una disposición absoluta.

Si los cambios de tamaño de la pantalla, entonces es posible que los componentes se solapan entre sí, si no hay suficiente espacio. Siempre haga sus diseños tienen un montón de espacio innecesario.

Una buena estrategia cuando se trabaja con un grupo de componentes es escoger uno de que la posición con respecto al recipiente a continuación, coloque todos los demás componentes relativos a ella para asegurarse de que puede mover el grupo y mantener las alineaciones.

Recuerde que algunos componentes pueden cambiar su tamaño, así como la ubicación y esto puede modificar la posición de los componentes posicionado con respecto a ellos.

También vale la pena señalar que hay otros componentes de diseño y no se limitan a la componet RelativeLayout.

El componente RelativeLayout se utiliza por defecto pero se puede cambiar esto para cualquiera de los otros componentes de diseño - Lineal, Tabla, Cuadrícula y marco.También hay otros componentes de contenedores que pueden ser utilizados en lugar de estos componentes de diseño estándar.

Más de esto más tarde.

Una cosa vale la pena conocer en esta primera etapa es que los componentes tienen propiedades de diseño que son proporcionados por su recipiente para que el conjunto de propiedades que hemos contemplado, en relación con el componente RelativeLayout son únicos a la misma. Esto es, si usted utilizar otro Layout entonces usted tiene que aprender sus propiedades de diseño desde cero.

De nuevo, esto es otro tema que tenemos que volver.

Para la mayoría de aplicaciones el componente RelativeLayout es una buena opción para una combinación de botones, texto, casillas de verificación y así sucesivamente.

Dimensionamiento

En comparación con el tamaño de un componente de posicionamiento es casi trivial.

Todos los componentes tienen una altura y una propiedad de ancho y estos corresponden a la altura y anchura dibujado cuando el componente está en realidad representa en la pantalla.

Usted puede haber notado que hay lo que parecen ser controladores de tamaño de los componentes que se colocan en el Diseñador. Sin embargo, si intenta arrastrar estos para cambiar el tamaño de decir un botón te darás cuenta de que muchas veces no sucede gran cosa.

La razón es que la mayoría de los componentes cambian de tamaño para acomodar a su contenido. Este comportamiento de tamaño automático está establecido por la disposición: ancho y el diseño: altura propiedades. Usted puede modificar esta escribiendo en un tamaño por ejemplo exacto 100dp en el cuadro siguiente valor tot propiedad.

También observa que se puede establecer un máximo y un mínimo para la mayoría de los componentes.

Configuración de un máximo resultará que el contenido que se trunca si no encaja. Configuración de un mínimo es a menudo la mejor plan porque entonces el componente aumentará de tamaño cuando sea necesario.

Gravedad

Ahora llegamos a una propiedad que no es tan importante, pero necesita ser discutido porque suena importante.

La gravedad es básicamente sólo otro nombre para la alineación. Si usted tiene un botón y establecer su propiedad gravedad al inicio y luego el texto que contiene se alineará a la parte superior del interior del botón. Hay un montón de posibilidades de alineación se puede establecer la gravedad para pero la mayoría son bastante obvias. La parte confusa es que muchos componentes tienen una propiedad de alineación de texto que puede ser utilizado para anular el ajuste de la gravedad.

La gravedad es más importante cuando se utiliza con un componente de diseño diferente - la disposición lineal cuando la propiedad layout_gravity establece cómo el componente debe alinearse dentro de la disposición lineal - más de esto más tarde.

El Árbol de componentes

Si se mira a la esquina superior derecha de Android Estudio en el modo de diseño, verá una ventana llamada Árbol de componentes.

Esto es casi explica por sí mismo y casi no necesita mucho más que llamar su atención.

Sin embargo nota que se puede ver la estructura de árbol de la distribución a partir de contenedor Disposición. En el caso de un proyecto predeterminado se puede ver que el diseño predeterminado es RelativeLayout y se puede ver la totalidad de los otros componentes correctamente anidados dentro de sus contenedores primarios.

Observe que puede seleccionar y eliminar elementos de diseño directamente en el árbol. Esto es útil cuando se tiene un esquema complejo que ha ido tan mal que tienen dificultades para seleccionar los componentes de forma fiable.

Una operación interesante que vale la pena conocer, incluso si no se utiliza muy a menudo es Morphing. Si selecciona un elemento en el árbol, haga clic derecho y seleccione Morphing se le presentará con una lista de posibles alternativas. Así, por ejemplo, usted puede cambiar un botón para un botón de activación una así sucesivamente.

Un ejemplo simple botón

Como el primer lugar de una simple demostración nos dejó un botón en el Diseñador. Alinearlo con el padre en la esquina superior izquierda - esto debería ser fácil, aparte de la tendencia a ajustarse a los bordes superior e izquierdo.

Si le resulta difícil obtener una posición aproximada y luego introduzca los márgenes exactos entonces siempre recuerde que usted puede ir a la ventana de propiedades y entrar directamente:

El gran problema con este enfoque es que si selecciona el componente y lo mueve ni un poco lo más probable es que se ajustará a la orilla y usted tendrá que introducir los valores de la propiedad de nuevo.

Luego se coloca un widget de texto grande en el Diseñador. En este caso la alineación que queremos es que el texto esté en la misma línea que el texto en el botón. Esta es una alineación de línea de base, pero si tienes Diseñador ampliada para que pueda ver el área completa de la pantalla lo más probable es lo único que podrá hacer es alinear a la parte superior o inferior del botón:

Para lograr la alineación de línea de base que tienes que usar cerca del 100% de zoom. Utilice las herramientas de zoom en la parte superior derecha del diseñador.

En muchos casos, si no se puede conseguir la alineación que desee a continuación, aumentar el zoom al máximo es a menudo la forma de lograr lo que estamos tratando de hacer.En este caso se puede mover el widget de texto a cerca de la ubicación correcta y que se ajustarán a la alineación de la línea de base:

Usted puede ver el cambio en el factor de zoom desde el tamaño de la barra de título y el mensaje. No es fácil definir el diseño de interfaz de usuario cuando no se puede ver toda la pantalla.

Entonces, ¿qué debe hacer?

Usted podría comprar un monitor más grande para que pueda trabajar de forma interactiva en el 100% de zoom todo el tiempo.

Usted podría desacoplar la ventana de diseño que que tiene el área completa de la pantalla para trabajar con ellos.

Por último se puede utilizar el hecho de que usted sabe lo que está haciendo para establecer el diseño: línea de base alignComponent: línea de base para el objeto Button en la ventana de propiedades.

en la práctica, el zoom dentro y fuera suele ser la opción más fácil.

Orientación Y Resolución

Uno de los mayores desafíos en la creación de aplicaciones para Android está permitiendo para la gama de tamaños de pantalla y orientaciones. Android Estudio le permite ver su diseño

en una amplia gama de dispositivos, orientaciones y resoluciones. Esto hace que sea mucho más fácil.

Podemos probar nuestra disposición en modo horizontal con sólo seleccionar la opción paisaje:

También puede ver lo que su interfaz de usuario se ve como en la gama completa de tamaños de pantalla compatibles seleccionando Vista previa de todos los tamaños de pantalla:

Para diseños simples, esto es probablemente suficiente, pero Android tiene más en la manga para ayudarle a trabajar con diferentes pantallas de tamaño. En particular, se puede hacer uso de "fragmentos" y usted puede crear un diseño distinto para cada orientación de la pantalla y la resolución.

Por ejemplo, si crea un nuevo paisaje archivo de diseño llamado activity_main.xml es decir, exactamente el mismo que el archivo de diseño retrato ya ha creado, pero en la carpeta

layout-tierra. Ahora puede editar el diseño del paisaje y este será usado automáticamente cuando el usuario gira el dispositivo en modo horizontal.

Lo que pasa es que cuando se inicia su aplicación el sistema recoge el mejor archivo de diseño disponibles para la pantalla de acuerdo a lo que se ha almacenado en las carpetas de recursos es decir, el diseño para el retrato y el diseño-tierra para el paisaje ..

Cuando se gira el dispositivo se reiniciará el sistema de su aplicación y carga el mejor diseño. Si sólo tiene un diseño retrato entonces se utiliza para todas las orientaciones, pero si usted tiene un archivo de diseño de paisaje, entonces se usará para el modo de paisaje.

Por ejemplo: si le añadimos un diseño de paisaje, utilice Crear Variación del paisaje, a la disposición de los botones y el texto dado anteriormente entonces inicialmente la disposición retrato se utiliza como plantilla para el diseño de paisaje.

Pero lo que se quiere colocar el texto en el botón en el modo de paisaje:

Ahora bien, si se ejecuta la aplicación utilizando el simulador va inicialmente ver la pantalla retrato. Si gira el simulador para el modo horizontal - usar Ctrl-F11 - a continuación, dependiendo de la velocidad de su máquina, verá una pausa donde la disposición retrato es visible y luego se cambiará a la disposición del paisaje.

Si no parece funcionar darle tiempo porque puede ser muy lento - recuerde que necesita un reinicio aplicación completa.

Si también ver la aplicación en una amplia gama de dispositivos que puede girar con el paisaje y ver su diseño horizontal personalizado.

En general, el mejor plan es crear un diseño retrato completo y generar un diseño de paisaje lo más tarde posible en el desarrollo por lo que no tiene que repetir retoques de interfaz de usuario.

Observe también que la conmutación automática de diseños hace que un problema potencial. Cuando se cambia el diseño de su aplicación se reinicia y esto significa que puede perder su estado actual - es como si su aplicación sólo se ha iniciado por el usuario. Tenemos que mirar en la aplicación del ciclo de vida y cómo preservar el estado para resolver este problema - ver más adelante.

También puede utilizar el mismo enfoque para apoyar diferentes resoluciones de pantalla. La idea es la misma - varios archivos xml diseño están disponibles uno para cada resolución y el sistema selecciona automáticamente cuál usar.

Esto es un poco más complicado de lo que se trata de orientación, ya que podría así tener que proporcionar diferentes imágenes de resolución para que el diseño se ve bien - más sobre esto después de que hemos mirado los recursos y la gestión de recursos.

Esto es sólo nuestro primer vistazo a un aspecto particular del desarrollo de aplicaciones para Android que hace más complicado que el desarrollo para un tamaño de pantalla fija - que resulta no ser tan difícil como podría parecer a primera vista.

Una primera aplicación

Como un ejemplo de la construcción de una aplicación sencilla utilizando el diseño y Diseñador Construyamos una calculadora.

Algunas de las técnicas utilizadas en esta aplicación son un poco más allá de lo que hemos cubierto hasta ahora, pero usted debería ser capaz de seguir y es el momento de mostrar lo que algo más que una sola aplicación botón se parece.

Esta es una muy simple calculadora - tiene sólo nueve botones numéricos y una pantalla. Toma los valores en cada uno de los botones y los añade a un total acumulado. No hay botones de operador, sumar, restar o claro - pero se puede agregarlas.

Iniciar un nuevo proyecto Actividades blanco llamado ICalc o lo que quieras llamarlo. Acepte todos los valores predeterminados.

El principio de funcionamiento es que vamos a establecer una red de diez botones. Ajuste cada botón para 0 a 9 como una etiqueta de texto. A continuación, vamos a asignar el mismo manejador onClick a cada uno de los botones. Todo lo que va a hacer es recuperar la proyección título de texto en el botón, convertirlo a un número entero, añadirlo a la suma de capital y luego almacenar de nuevo en el TextView después de convertir de nuevo a una cadena.

El CódigoAsí que el código es bastante fácil.

Necesitamos un campo privado para mantener el total de ejecución en:

private int total = 0;

Lo siguiente que necesitamos una función onButtonClick que se va a utilizar para controlar el evento onClick para todos los botones. Véase el capítulo 2 si usted no sabe acerca de la gestión de eventos.

El botón que el usuario ha hecho clic se pasa como un objeto de vista como el único argumento de la función y podemos usar esto para obtener su título de texto:

public void onButtonClick(View v) { Button button = (Button) v; String bText = button.getText().toString();

Ahora que tenemos el botón de título por ejemplo, 0, 1, 2 y así sucesivamente podemos convertirlo en un entero y añadirlo al total acumulado:

int value = Integer.parseInt(bText); total += value;

Por último tenemos la TextView usando su Identificación (véase el capítulo 2) y ajustar su texto al total convierte en una cadena:

TextView myTextView = (TextView) findViewById(R.id.textView); myTextView.setText(Integer.toString(total)); }

El controlador de eventos completa es:

private int total = 0; public void onButtonClick(View v) { Button button = (Button) v; String bText = button.getText().toString(); int value = Integer.parseInt(bText); total += value; TextView myTextView = (TextView) findViewById(R.id.textView); myTextView.setText(Integer.toString(total)); }

Pon este código dentro de la clase MainActivity como uno de sus métodos.

Al entrar en este código podrás ver muchas de las clases y métodos en rojo. Esto se debe a que es necesario que se destinen a ser utilizadas por el proyecto. Usted puede hacer esto manualmente, añadiendo las declaraciones de importación necesarias en el inicio del archivo. Es mucho más fácil para colocar el cursor en cada uno de los símbolos en alt rojo y pulse + enter y seleccione Importar clase si es necesario.Esto debe ser cada vez más una segunda naturaleza por ahora.

El LayoutAhora dirigimos nuestra atención a la disposición. Abra el archivo de diseño, elimine el texto predeterminado y coloque un solo botón en la superficie de diseño.

Haga doble clic en él, se trata de un acceso directo a las propiedades de texto e id, y entre 7 como su propiedad Text.Coloque el botón en la parte superior derecha de la pantalla con un poco de espacio.

Luego vaya a la ventana Propiedades y encontrar la propiedad onClick. Póngalo a onButtonClick:

Para crear la red de diez botones seleccione el primer botón y copiarlo en el portapapeles. Siguiente pega el botón de copiado a la superficie de diseño y cada posición de tiempo dentro de la red con respecto a los botones que ya están presentes. Ahora usted tiene la rejilla de botones que todos dicen 1. Haga doble clic en cada uno a su vez y cambie el texto a 8,9, 4,5,6, 1,2,3 y 0.

Mediante el uso de la copia y pegar truco ahora tiene diez botones configurados con la misma controlador de eventos onClick y al que tenía que hacer era editar la propiedad Text.Trate de asegurarse de que cada botón se agrega es relativo a uno de los otros botones. Usted puede comprobar que usted ha hecho esto con éxito arrastrando uno de los botones y ver si todos siguen! Si uno dos no se trate de poner ellos en relación con uno de los otros botones. Si usted encuentra cualquier zoom difícil posicionamiento en.

Si te metes en un lío a todos borrar y empezar de nuevo.

Para hacer esta mirada más como un teclado, seleccione la tecla 0 y el tamaño de forma que ocupa un ancho doble:

Por último añadir un Texto grande Ver en la parte superior.Puede colocarlo en relación con la tecla fila y the7 superior y luego dimensionar de forma que se extiende por todo el conjunto de botones.

Ahora usted debería ser capaz de mover todo el bloque cuando se mueve sólo el botón 7 para una nueva ubicación.Esto no siempre funciona porque uno o más de los botones están situados con respecto al recipiente.!

Es bueno saber que usted puede deshacer una acción mediante el uso de Ctrl-z. Si encuentra Diseñador demasiado difícil trabajar con crear este diseño, y puede ser difícil, es posible que prefiera para establecer las propiedades de diseño utilizando la ventana de propiedades.

Por último, ejecute el programa de la forma habitual y que bebe será por favor para descubrir su primera aplicación no calcular realmente las cosas!

Intente girar el emulador para ver cómo se ve en modo horizontal.

No está mal, pero como prometió ya que la aplicación se reinicia a perder cualquier cálculo que estaba realizando ya que la aplicación se reinicia cuando cambia la orientación.

Si puedes probarlo en un dispositivo Android verdadera hacerlo - es más fácil de averiguar lo que realmente siente.También hacer echar un vistazo a lo que el diseño se ve como en una serie de pantallas y orientaciones.

Esto no es mucho de una calculadora, pero podría hacerlo en una realmente buena.

alinear a la derecha del texto en la pantalla

añadir un botón + y - e implementar la acción

permite al usuario entrar en número de varios dígitos

añadir una tecla del punto decimal y todo un flotador de varios dígitos

añadir un * / claves

añadir una tecla de borrado

etcétera ...

Hay mejores formas de implementar el diseño y vamos a volver al programa de calculadora en capítulos posteriores.

Resumen

Puede crear el archivo de diseño XML a mano, pero utilizando el diseñador es más fácil. 

Todavía es útil saber cómo funciona el archivo XML para que pueda editarlo cuando Diseñador le permite bajar de alguna manera. 

El Diseñador modifica la forma en componentes miran en el diseño cambiando las propiedades de un componente. 

Cómo colocar un componente depende del diseño que está utilizando. 

El RelativeLayout permite grabar componentes de posición relativa entre sí o al contenedor. 

El diseñador puede cambiar varias propiedades para colocar el componente donde usted quiera. 

Utilice el Árbol de componentes para seleccionar los componentes que son difíciles de seleccionar en el Diseñador. 

Puede utilizar la ventana de propiedades para seleccionar y establecer cualquier propiedad directamente. 

Si usted encuentra el posicionamiento o dimensionamiento difícil en el Diseñador procura acercar la imagen. 

Puede usar Android Studio para ver lo que su aplicación se ve como en diversos tamaños de pantalla y orientaciones. 

Puede copiar y pegar los componentes en el Diseñador de construir rápidamente diseños de interfaz de usuario repetidas. 

Un único controlador de eventos se puede unir a muchos componentes.

4. Aventuras Android - Controles básicos y Eventos

Trabajar con Android Studio hace que la construcción de la interfaz de usuario fácil con un editor interactivo, pero usted todavía tiene que encontrar la manera de manejar las cosas no es tan bueno. En este capítulo de nuestro libro electrónico en Android el camino fácil nos fijamos en los componentes de interfaz básicos y manejo de eventos en general - es decir, más allá de onClick.

Hemos pasado revista a los principios generales de la construcción de una interfaz de usuario, pero ahora tenemos que pasar algún tiempo mirando a los componentes más básicos que se pueden utilizar para crear una aplicación.

También tenemos que encontrar la manera de trabajar con cualquier evento y no sólo onClick. A pesar de que la mayoría de los controles se pueden utilizar con gran éxito utilizando sólo el evento onClick - hay otros tipos de eventos que no se pueden manejar simplemente estableciendo una propiedad onEvent en la ventana de Propiedades. En este capítulo analizamos en profundidad en el manejo de eventos Android.

Como antes se hará hincapié en el uso de Android Studio y el editor de diseño para obtener la mayor parte del trabajo realizado como sea posible.

Vamos a empezar con el problema de cómo escribir un controlador de eventos.

El Android Handler general Evento

Si ha utilizado otros idiomas aparte del Java se podría esperar controladores de eventos a ser simplemente funciones que se pasan a controles para registrarlos como detectores de eventos - es decir, funciones que son llamadas cuando se produce un evento. Puede ser que incluso ha usado un IDE que agrega controladores de eventos de forma automática para usted, pero Android Estudio actualmente no hacer esto - hay que añadir código para manejar y evento. Sin embargo, sí ayuda con la generación automática de este código.

Eventos en Java son un poco más complicado porque no se puede pasar una función como un argumento como puedas en JavaScript, C # y muchos otros idiomas - se puede en la última versión de Java pero será en algún momento antes de los marcos de la interfaz de usuario y catchup Android si alguna vez hacer. En Java funciones sólo puede existir como métodos de objetos por lo que si quieres pasar una función que tiene que pasar un objeto que tiene la función como método.

Como resultado de lo que debe pasar a registrar un detector de eventos es más complicado en Java que en muchos otros idiomas. La forma en que funciona todo fue inventado en la década de los marcos de Java de interfaz de usuario, tales como GWT y más tarde perfeccionó en Swing. Android utiliza el mismo enfoque.

Como ya se ha mencionado que no se puede pasar de una función que tiene que pasar un objeto que contiene una función que puede controlar el evento. Es evidente que la función de gestión de eventos tiene que ser capaz de manejar el evento y por lo tanto se define en función del tipo de evento.

Por ejemplo un evento onClick necesita un controlador que devuelve void y acepta un objeto View, que es el objeto del evento se produjo en.

Para asegurarse de que un detector de eventos tiene el tipo adecuado de manejo de eventos eventos de función se definen usando una interfaz.

Si usted recuerda una interfaz es como una clase sino que simplemente define las funciones que una clase tiene que soportar. Si una clase hereda o implementa una interfaz, entonces usted tiene que escribir código para cada función definida en la interfaz.

Por ejemplo, el OnClickListener es una interfaz que define una sola función

void onClick(View v)

cualquier clase que implementa OnClickListener tiene que tener una función onClick de este tipo.

Para crear un controlador de eventos para el evento onClick que tienes que hacer las siguientes cosas:

1. Crear una nueva clase que implementa la interfaz OnClickListener

2. Definir el controlador de eventos onClick encargo dentro de la clase

3. Crear una instancia de la nueva clase dentro de la actividad

4. Utilice el método setOnClickListener del botón para agregar el objeto detector creado en el paso 3 para el evento.

Este es el patrón general de que hay que seguir en la aplicación de cualquier controlador de eventos - sólo el nombre del objeto que tiene que crear, el método que hay que definir. Usted también tiene que descubrir qué información se pasa como estándar para el controlador de eventos.

Suena complicado - así es y hay maneras de simplificar, pero primero vamos a ver cómo se hace exactamente como se describe.

Esta no es la mejor manera de hacer el trabajo, pero es la forma en que todo funciona, en principio, y es importante entender lo que está pasando.

Esto es tanto un ejercicio para principiantes Java, ya que es una explicación de la gestión de eventos. Si su Java es buena no dude en saltar hacia delante.

Para implementar un controlador de eventos para el evento onClick primero tenemos que añadir una nueva clase al proyecto. Haga clic derecho sobre la carpeta bajo la carpeta de Java y seleccione Nuevo, Java Class y llamarlo MyOnClickListener.

Nota: Para los usuarios de otros idiomas, vale la pena señalar que Java tiene una convención casi irrompible que cada clase se almacena en su propio archivo del mismo nombre.

Siguiente editar MyOnClickListener leer:

import android.view.View; public class MyOnClickListener implements View.OnClickListener { public void onClick(View v){ //process event } }

Note que ahora hemos creado una clase con un método único que es nuestro controlador de eventos. En un caso real que iba a escribir un montón de código en lugar de la simple observación de que hizo algo que ocurrió el evento.

Ese es el primer paso completado. A continuación Mover a la Actividad y primero recuperar el objeto Button:

Button button= (Button)findViewById(R.id.button);

A continuación, creamos una instancia de nuestro detector de eventos:

MyOnClickListener Listener= new MyOnClickListener();

y, finalmente, utilizamos método setOnClickEventListener del botón para conectar su evento onClick a nuestro nuevo objeto detector:

button.setOnClickListener(Listener);

Eso pone todo junto:

@Override protected void onCreate( Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Button button= (Button)findViewById(R.id.button); MyOnClickListener Listener= new MyOnClickListener(); button.setOnClickListener(Listener); }

Ahora bien, si se ejecuta el programa, usted encontrará que la función onClick en la instancia MyOnClickListener se llama cuando se hace clic en el botón.

El mismo método general funciona para cualquier evento.

Usted simplemente tiene que descubrir el nombre de la interfaz de detector de eventos, crear una clase que lo implementa, cree una instancia de la clase y registrar el detector con el componente que genera el evento.

Esto no es muy práctico, ya que va a necesitar para crear una nueva clase para cada evento que desea manejar y además estas clases se va a contener un método y deberían ejecutarse sólo una vez.

Tiene que haber una manera mejor!

Ahora que usted ha visto los fundamentos de eventos de Java dirección Podemos ejemplo las dos formas que suele hacerse en la práctica.

Dos maneras de manejar un evento

Para evitar los gastos generales que puede utilizar uno de dos métodos posibles:

utilizar una clase anónima

implementar la interfaz en la actividad.

Clase AnonymousJava tiene clases anónimas por sólo la situación que estamos tratando de resolver. Te permite crear efectivamente un objeto, es decir, una instancia de una clase, sin tener que crear explícitamente una clase. La única pega es que no se puede crear una segunda instancia de la clase - esta es una manera de atajo de crear una instancia de un objeto.

En el caso de un controlador de eventos se puede tomar una interfaz e implementarlo como clase y crear una instancia de una sola vez. Esto es sólo taquigrafía azúcar, sintáctico si te gusta por lo que hicimos en la sección anterior.

Por ejemplo:

MyInterface instance=new MyInterface{ 

functions which are needed to implement MyInterface }  

Esto crea una instancia de la aplicación de MyInterface que está contenida dentro de las llaves. No hay necesidad de definir una clase para obtener una instancia - pero note que sólo se puede obtener una instancia.

Así que para nuestro manejador de eventos onClick usando una clase anónima hace las cosas mucho más fácil, ya que no necesitamos un archivo separado para mantener la nueva clase y, de hecho, ni siquiera necesitaría la nueva clase simplemente:

View.OnClickListener Listener= new View.OnClickListener(){ @Override public void onClick(View view) { //Implement event handling } }

y la instancia de nuestra oyente completa con nuestro controlador de eventos onClick de encargo está listo para ser utilizado como antes:

button.setOnClickListener(Listener);

Por supuesto, usted puede ahorrar una variable y sólo tiene que utilizar la clase anónima en el setOnClickListener como en:

button.setOnClickListener( new View.OnClickListener() { @Override public void onClick(View view) {

//Implement event handling } });

Nosotros no siempre tenemos que utilizar la variable de escucha, pero el costo es que tenemos que tener cuidado de no olvide cerrar la llamada a la función con un paréntesis.

La buena noticia es que Android estudio le ayudará a crear la clase anónima. Si usted comienza a escribir en OnClickListener que le proporcionará opciones para completar el nombre y usted puede seleccionar OnClickListener - que luego generar funciones ficticias para todos los métodos definidos en la interfaz. Todo lo que tienes que hacer es proporcionar el código en el cuerpo de cada una de las funciones que hace lo que quiere.

Implementar la interfaz en la actividadLa forma alternativa de hacer las cosas es simplemente usar la clase MainActivity para implementar la interfaz de detector de eventos. Esto parece un poco extraño cuando lo primero que ves, pero es la aproximación más cercana a la forma en otros idiomas hacen el trabajo.

Por ejemplo, para controlar el evento onClick tenemos que añadir los "instrumentos" para la interfaz de la Actividad:

public class MainActivity extends Activity implements View.OnClickListener {

Ahora todo lo que tiene que ocurrir es que la clase de actividad tiene que implementar el manejador de eventos onClick:

@Override public void onClick(View view) { //Handle Event }

Todo lo que queda es añadir el detector de eventos utilizando setOnClickEventListener pero ¿cuál es la instancia?

Si recuerdan lo que sucede es que el sistema crea una instancia de la clase MainActivity para obtener su aplicación en ejecución y la instancia actual de una clase es siempre "esto".Así que tenemos que añadir al método onCreate:

button.setOnClickListener(this);

En muchos sentidos, esta última forma de hacer las cosas es la más sencilla.

Tiene el inconveniente de que hay que añadir un "instrumentos" para cada evento que se va a manejar, pero esto podría ser una ventaja ya que le permite ver qué eventos se están utilizando.

Observe también que el uso de este método se ajusta a todos los controladores de eventos utilizando

somecontrol.setOnSomeEvent(this);

Esto también implica que usted va a utilizar el mismo controlador de eventos para un evento, independientemente de que el control ha generado el evento. Es decir que va a escribir una sola función onClick y esto se utilizará para todos los controles que se utilizan setOnClickEvent (este) en.

Si desea utilizar varios controladores de eventos - uno para cada control entonces usted necesita utilizar el enfoque de clase anónima.

Qué enfoque de controladores de eventos debe usted utilizar?En la práctica el enfoque de clase anónima parece ser la mejor porque, aunque es un poco más complicado que es completamente general. Uso de la Actividad para implementar la

interfaz falla cuando se necesitan diferentes controladores de eventos vinculados a cada control.

En este sentido vale la pena el esfuerzo extra y es la utilizada en el resto de este libro. Si desea utilizar el método XML introducido anteriormente para el evento onClick o implementar la interfaz en el enfoque de la actividad entonces esto debe causar ningún problema.

Los controles de entrada básicos

Ahora que hemos descubierto cómo funcionan los eventos es el momento de echar un vistazo a los controles de entrada más usados.

Los controles de entrada básicas son:

Botones

Los campos de texto

Las casillas de verificación

Botones de radio

Botones Toggle

Si ha programado el uso de otros marcos de muchos de estos IU serán conocidos por usted y es probable que pueda saltar a sólo los que le interesan.

Comenzando desde el principio sin embargo Vamos a revisar el Botón pero en un poco más de detalle

Botones

Hay dos tipos básicos de botón - Botón y ImageButton - pero el Android Estudio Caja de herramientas tiene tres botones, el pequeño botón y ImageButton.

Pequeño Button es sólo un control Button estándar, pero con un estilo aplicado para hacer el tipo de letra más pequeño y por lo tanto más adecuado para un pequeño botón. El ImageButton es lo mismo que el botón, pero tiene una propiedad src que puede ajustarse a una imagen que se muestra como el icono del botón y no mostrar ningún texto.

Las principales propiedades que se trabaja en el caso de un botón es son cosas como fondo - que se pueden ajustar a un color o un gráfico. Puede pasar mucho tiempo cambiando la manera botones se ven, sino en el principal la única propiedad importante de un botón es su manejador onclick.

Un botón en la interfaz de usuario a hacer clic.

Si usted pone un ejemplo de un botón, el pequeño botón y ImageButton en la superficie de diseño se puede utilizar la ventana de propiedades para personalizarlos.

Ajuste el fondo del botón de color gris oscuro, haga clic en los puntos suspensivos a la derecha de la propiedad y luego seleccionar la pestaña Sistema en el navegador de recursos que aparece. Desplácese hacia abajo y verá un conjunto de colores predefinidos que se pueden utilizar. Encuentra darker_grey y seleccionarlo.

Para el pequeño botón de establecer la propiedad del fondo de un dibujable de la misma manera - es decir, desplácese hacia abajo en el navegador de recursos hasta que vea "drawables" y luego seleccione ic_menu_add.

Vamos a discutir el uso de los recursos y drawables en un capítulo posterior. Por ahora simplemente asumen que son estilos y elementos gráficos que se pueden seleccionar.

Repetir la tarea para el ImageButton pero establecer la propiedad src para ic_menu_add.

El resultado es los tres botones que se muestran en la siguiente imagen:

Puede pasar mucho tiempo explorando maneras de hacer uso de las propiedades de un botón para diseñarlo apenas como usted quiere que se vea.

Para adjuntar un controlador de eventos click en los tres botones que puede simplemente definir una función:

public void doButtonClick(View e){ //process event }

en la actividad y establecer la propiedad onClick en cada botón para doButtonClick.

Usted puede encontrar ejemplos del uso de los botones de esta manera en los capítulos anteriores.

Ahora que sabemos cómo manejar eventos utilizando clases anónimas vale la pena hacer el mismo trabajo de esta manera.

Como queremos asignar el mismo controlador de eventos para los tres botones tenemos que crear una instancia de OnClickListener. Todo lo que tienes que escribir es:

View.OnClickListener onClick=new O

y seleccione OnClickListener y dejó Android Estudio generar:

View.OnClickListener myonClickListener= new View.OnClickListener() { @Override public void onClick(View v) { 

} }

Observe que no genera un punto y coma final para no olvide añadirlo. También es necesario rellenar los datos del controlador de eventos onClick - sólo hay tanta Android Studio puede hacer por medio de la escritura de su programa.

Por último es necesario configurar la instancia en cada uno de los botones:

Button button = (Button)findViewById(R.id.button); 

Button button2 = (Button)findViewById(R.id.button2); ImageButton imgbutton = (ImageButton)findViewById(R.id.imageButton);

button.setOnClickListener(myonClickListener); button2.setOnClickListener(myonClickListener); imgbutton.setOnClickListener( myonClickListener);

Ahora al hacer clic en cualquiera de los botones de la myonClickListener se llama.

También vale la pena señalar que mientras que un botón no tiene otra función en la vida más que para ser pulsado todos los otros controles también puede responder a un evento onClick. Es decir, se puede utilizar cualquier cosa como un botón si quieres.

Propiedades de expertos

Si usted ha mirado en cualquier ejemplo del uso de botones en la documentación, o si nos fijamos en algo mayor código de Android, usted puede descubrir algunos "trucos" que parece que no puede realizar usando Android Studio - esto no es realmente el caso .

Por ejemplo, supongamos que desea establecer un icono dentro de un botón de texto estándar para que muestre a la izquierda del texto que contiene el botón. Esto parece ser imposible si se restringe a sí mismo a las propiedades que se presentan en la ventana de propiedades.

Si las operaciones de búsqueda de los detalles de las propiedades que Button hereda encontrará

drawableLeft

drawableRight

drawableStart

drawableEnd

drawableBottom y

drawableTop

que no están en la lista de la ventana de propiedades. Estos le permiten mostrar un dibujable, es decir, un gráfico, en el lugar especificado en relación con el texto.

De manera que cambiar drawableLeft al recurso icono queremos mostrar haría el trabajo, pero ¿cómo podemos configurarlo?

La solución es que no hay un icono a la derecha de la parte superior de la ventana de propiedades que se puede hacer clic para ver "Propiedades de expertos", es decir todas las propiedades que admite el control.

Si selecciona el botón y haga clic en Propiedades de expertos verá entre las nuevas propiedades que figuran - drawableLeft.Haga clic en el botón de puntos suspensivos junto a él y seleccione un dibujable de su opción para mostrar el icono a la izquierda del texto:

En la mayoría de los casos, sólo tendrá que trabajar con las propiedades que se muestran en la ventana de propiedades, pero sí es necesario saber cómo acceder al resto. También vale la pena teniendo en cuenta que algunas de las propiedades de expertos no se mostrarán correctamente por el diseñador a fin de utilizar con cuidado.

Los campos de texto

TextFields son la manera de conseguir que el usuario introduzca un texto para que se procese y como se puede adivinar que forman una parte importante de la mayoría de las interfaces de usuario.

Hay un montón de campos de texto proporcionado en la caja de herramientas, pero todos funcionan de la misma manera que sólo difieren en el tipo de entrada que esperan que el usuario escriba. En el curso de aplicaciones en desarrollo se encontrará con la mayoría de ellos, tarde o temprano, pero que realmente sólo necesita saber cómo utilizar uno de ellos para entender cómo funcionan.

Si ha utilizado otro marco UI entonces habrás encontrado con algún tipo de campo de texto antes, pero el control de Android es un poco diferente, ya que en general, ofrece al usuario un teclado virtual personalizado - un editor de métodos de entrada IME.

Usted puede construir sus propias IME pero por el momento le permite utilizar sólo los proporcionados por el sistema.

Si desea que el simulador de Android para hacer uso de la IME que un dispositivo Android verdadera usaría entonces usted necesita para anular la selección del teclado de hardware opción actual cuando se crea la AVD (dispositivo virtual de Android). Si el simulador hace uso del teclado de la máquina host que no se ve el IME en absoluto.

Lo primero que debemos aclarar es que a pesar de que parece que hay una gran cantidad de diferentes tipos de controles de campo de texto en la caja de herramientas que son ejemplos del control EditarTexto con su propiedad InputType establecido en un valor particular. Cuando

usted pone una en la superficie de diseño, verá que es de tipo EditarTexto y si se desplaza hacia abajo a su propiedad InputType puede cambiar el tipo de entrada del campo de texto se encargará.

Cuando se utiliza un InputType particular, el usuario se presenta con un teclado virtual que es apto para escribir un valor - por ejemplo, si se especifica un valor numérico a continuación, el teclado sólo muestra los números.

Usted también consigue una tecla de acción en la parte inferior derecha del teclado que el usuario puede pulsar para completar la egSend acción para un mensaje SMS decir.

Para seleccionar el botón de acción para un teclado especial, utilice un botón Enviar para una entrada de texto general, entonces usted tendrá que utilizar la vista Propiedades de Expertos y seleccione un valor para la propiedad imeOptions.

Para ajustarlo a actionSend ejemplo obliga a un botón Enviar para que se muestre:

Hay muchas otras propiedades que se pueden utilizar para personalizar un campo de texto, pero hay una tarea estándar pena explicar en detalle - escribir un controlador para el evento onEditorAction.

El EditorAction Evento

Volviendo al control EditarTexto vamos a añadir un controlador para el botón Enviar. Esto proporciona otra oportunidad para un ejemplo del proceso general de la adición de un controlador de eventos.

En primer lugar un EditarTexto de un correo electrónico en la superficie de diseño y el uso de las propiedades de expertos como se describe en la última sección para añadir un botón Enviar para el IME que aparece cuando el usuario introduce texto - encontrar imeOptions y seleccione actionSend.

Antes de que pueda manejar cualquier nuevo evento que tiene que descubrir el nombre de la interfaz de detector de eventos y el método de Seton para ese evento.

Para el evento EditorAction la documentación revela que la interfaz de escucha se llama OnEditorActionListener y el método Seton es setOnEditorActionListerner.

Así, utilizando esta información podemos proceder como antes y una clase anónima para implementar el controlador de eventos. En este caso también podríamos hacer el trabajo

dentro de la setOnEditorActionListener como el controlador de eventos sólo se necesitará por éste de control:

EditText email = (EditText) findViewById( R.id.editText); email.setOnEditorActionListener( new TextView.OnEditorActionListener() { @Override public boolean onEditorAction(TextView v, int actionId, KeyEvent event){ return false; } });

Al igual que antes usted no tiene que escribir todo esto en. Android Estudio generará por usted si escribe nueva ONED .. y selecciona la opción correcta.

Ahora todo lo que queda es escribir el controlador de eventos - onEditorAction.

Usted puede buscar los detalles del controlador de eventos en la documentación, pero el trozo generado para la función de controlador es a menudo suficiente para hacerle saber lo que los parámetros son:

@Override public boolean onEditorAction( TextView textView, int i, KeyEvent keyEvent)

En este caso TextView es el control que el evento está asociado con, i es el identificador de acción y KeyEvent es nulo a menos que se utilizó la tecla enter.

Si la acción se ha consumido entonces la rutina debe devolver true cuando no hay otros controladores tendrán la oportunidad de procesarlo. En Java en general los eventos pueden ser transmitidos a otros controles que contienen el origen del evento.

Para un ejemplo sencillo vamos a añadir un TextView y transferir el texto que el usuario ha introducido cuando seleccionan el botón de enviar - imagino que este es el envío de un correo electrónico o sms o algo más emocionante.

Todo lo que tenemos que hacer es conseguir emitir el parámetro v a un EditarTexto y encontrar el TextView que hemos añadido a la interfaz de usuario. A continuación ponemos a prueba para ver si el usuario selecciona el botón de envío o algún otro botón y si tenían que transferir el texto:

public boolean onEditorAction(TextView v, int actionId, KeyEvent event) { EditText email=(EditText) v; TextView tv=(TextView) findViewById( R.id.textView); if(actionId== EditorInfo.IME_ACTION_SEND){ tv.setText(email.getText()); 

} return true; }

Observe el uso de la clase estática EditorInfo para obtener el identificador de entero correspondiente a la acción de envío.La clase EditorInfo tiene un montón de constantes y métodos útiles.

Las casillas de verificación

Una casilla de verificación es un elemento bastante obvio UI.Se muestra una etiqueta pequeña y controlada por la propiedad de texto y una garrapata o ninguna garrapata. El usuario puede activar o desactivar tantas casillas como se desee.

En la mayoría de los casos, no se molestan en tratar con el estado de una casilla de verificación hasta que el usuario pulsa algún otro control - por lo general un gran botón marcado Done o similar. A continuación, puede descubrir el estado de la casilla de verificación por el simple uso del método isChecked que devuelve verdadero o falso.

Por ejemplo, si usted tiene una opcion con checkBox Identificación entonces usted puede descubrir su estado cuando un botón en algún lugar de la vista se hace clic en el uso de:

public void onClick(View v){ CheckBox box= (CheckBox) findViewById( R.id.checkBox); boolean checked = box.isChecked(); }

La casilla de verificación también apoya el evento onClick y esto puede ser usado para procesar los cambios en su estado y se puede configurar el controlador de eventos onClick usando la ventana Propiedades como en el caso de un botón.

Así que para manejar el cambio checkBox de Estado todo lo que tienes que hacer es configurar su controlador de eventos onClick a:

public void onClick(View v){ CheckBox box=(CheckBox) v; 

boolean checked = box.isChecked(); }

Si necesita modificar un valor CheckBox luego usar el setChecked o los métodos de alternancia.

Los interruptores y botones de alternancia

Los interruptores y botones de alternancia son sólo CheckBoxes en otro formato. La tienda de uno de los dos estados y que cambia de estado cuando el usuario hace clic en ellos - al igual que un CheckBox.

Puede comprobar el estado de un botón interruptor / palanca utilizando el método isChecked y usted puede utilizar su evento onClick para monitorear cuando sus cambios de estado. La única diferencia real es que se puede utilizar el Texton y textOff para establecer lo que se muestra cuando el interruptor / conmutador está encendido o apagado.

Vale la pena teniendo en cuenta que el interruptor es nuevo en Android 4 y no funciona en versiones anteriores.

Botones de radio

El último miembro de los "simples" controles de entrada es el RadioButton. Esto funciona exactamente igual que un CheckBox en que puede estar en uno de dos estados, pero la gran diferencia es que un conjunto de componentes RadioButton trabaja en un grupo y sólo uno de ellos puede ser seleccionado a la vez.

La razón de la "botón de radio" plazo es que en los primeros días de la electrónica radios de coche tenía botones mecánicos de ajuste dispuestos en una línea que permita que el conductor seleccione rápidamente en uno emisora pulsando un botón. Cuando pulsó un botón nuevo el botón actual apareció de manera que un solo botón se pulsa en un momento dado - asegurándose de que sólo se escuchó una estación a la vez.

La única complicación en el uso de componentes RadioButton es asegurarse de que los agrupan correctamente. Para ello tenemos que hacer uso de un contenedor RadioGroup que se utiliza para contener todos los botones que funcionan juntos.

Utilizando Android Studio puede crear un grupo de componentes RadioButton colocando primero un recipiente RadioGroup en la superficie de diseño y luego colocar tantos RadioButtons dentro del contenedor como necesite.

Verá el RadioGroup destacada en naranja cuando se pasa el cursor sobre él listo para soltar un RadioButton en ella. Si un grupo de componentes RadioButton no funcionan como se espera lo más probable es que usted no tiene todos los botones dentro del RadioGroup.

Todos los componentes RadioButton en un RadioGroup trabajar automáticamente de modo que sólo un botón se puede seleccionar a la vez - usted no tiene que hacer ningún trabajo adicional para implementar este comportamiento.

Para saber qué botón se ha seleccionado puede utilizar el método isChecked como en el caso de la CheckBox - de hecho, se puede trabajar con un conjunto de componentes RadioButton exactamente de la misma manera que un conjunto de casillas las únicas diferencias son el uso de la RadioGroup y un solo botón se pueden seleccionar en cualquier momento.

Usted puede utilizar el evento onClick para detectar cuando cualquier botón se ha modificado y el setChecked o los métodos de ajuste puedan modificar el estado de un botón.

Resumen

En Java no se puede pasar de una función para configurar un controlador de eventos que tiene que pasar un objeto.

Cada tipo de evento tiene su propia interfaz que es utilizar para crear un objeto que tiene los métodos necesarios para el evento.

La manera más directa de crear un controlador de eventos es crear una nueva clase que implementa la interfaz y luego crear una instancia de la clase para controlar el evento.

Para evitar los problemas de tener que crear una nueva clase para cada controlador de eventos Java introdujo la clase anónima. Puede utilizar una clase anónima para implementar una interfaz de eventos y crear una instancia del mismo en un movimiento.

Alternativamente, puede utilizar la actividad para implementar la interfaz.

Los controles básicos que componen la mayor parte de la sencilla interfaz de usuario de Android son

Botones Los campos de texto Las casillas de verificación Botones de radio Botones Toggle

Cada control se personaliza utilizando sus propiedades y controladores de eventos

Algunas propiedades están ocultos a usted por Android Estudio menos que seleccione el botón de Expertos.

5. Aventuras Android - Trabajar con formatos

La interfaz de usuario Android se basa en las subclases de vista. Un grupo particular de objetos derivados de Vista son los diseños. Un diseño es un contenedor para otros Ver derivados de objetos. Cuando se le pide al diseño para hacer sí mismo, hace que toda la vista objetos que contiene dispuesto en el interior del área de la pantalla que ocupa.

Al usar Android Estudio que tiene sentido utilizar el editor de formato. También vale la pena acostumbrarse al XML que genera porque a veces este es el más rápido, y en ocasiones la única, manera de hacer los cambios que desee.

El diseño por defecto utilizado por Android Studio es el RelativeLayout y hemos mirado a usarla en capítulos anteriores - pero no es el único diseño que puede utilizar con el Diseñador.

Hay cinco Layouts soportados actualmente:

FrameLayout

LinearLayout

RelativeLayout

TableLayout

GridLayout

De éstos RelativeLayout y LinearLayout son los más utilizados, con FrameLayout viene un distante tercer lugar.Los dos últimos, TableLayout y GridLayout, son adecuados para tipos especiales de interfaz de usuario y no son tan fáciles de usar o como bien soportado en Android Studio. Por esta razón, este capítulo presenta los tres diseños que usted puede conseguir la mayoría del trabajo de IU básico hecho con.

Antes de analizar estas alternativas y cómo trabajar con ellos vale la pena llegar a enfrentarse con las ideas básicas de Layouts y los principios que son comunes a la mayoría de los diseños.

Propiedades de la maquetación

Mayormente se tiende a pensar en las propiedades que son relevantes para un control como pertenecientes al control, pero un diseño puede hacer su trabajo de muchas maneras y podría necesitar el control para tener un montón de propiedades muy específicas para determinar la forma en que se coloca.

En otras palabras, las propiedades que un control necesita para trabajar con un diseño dependen del diseño elegido y esto hace que las cosas difíciles de organizar. La forma más sencilla pero inviable de implementar esto sería insistir en que todos los controles

implementado todos los bienes utilizados por cada Layout - incluso los que no se utilizan actualmente.

La solución al problema es que cada Diseño define una clase anidada derivado de LayoutParams, que tiene todas las propiedades que necesita el control de definir. El control crea una instancia de la clase LayoutParams apropiada y así varía los parámetros que tiene acceso a la función del contenedor de diseño que se encuentra en.

Así, en el Diseñador y en la ventana Propiedades de un control tiene dos tipos de propiedades:

Las propiedades que pertenecen al objeto

Propiedades que son requeridos por el objeto Layout.

Se puede decir que las propiedades de diseño, ya que son del nombre layout_ forma en el archivo XML. Se los puede ver en la ventana Propiedades en el diseñador, pero se muestra como el diseño: nombre.

También vale la pena conocer en esta primera etapa que el Diseñador menudo presenta un conjunto simplificado de diseño: propiedades que luego asigna a un conjunto más amplio y más confuso de layout_ propiedades en el XML.

Anchura y Altura

El conjunto exacto de propiedades de diseño que se ve depende del diseño que utilice. Sin embargo, hay dos que apoyan todos los diseños:

layout_width

layout_height

Estos visualización en la ventana Propiedades como

diseño: Ancho

diseño: altura

Se podría pensar que la anchura y la altura de un control eran propiedades que deberían pertenecer a un control, pero aquí las cosas son más sutiles.

Un control no necesariamente tiene un tamaño fijo.

Se puede, por ejemplo, pedir al diseño para darle el mayor espacio posible, en cuyo caso la Disposición establece el tamaño del control. Esta es la razón por la que los controles tienen layout_width y layout_height y no sólo anchura y altura.

Puede establecer estas propiedades para cualquiera de los tres valores posibles:

un tamaño fijo, por ejemplo 24px 

wrap_content - establece el tamaño de modo que sólo se adapta el contenido del control sin recortes 

match_parent - le permite el control a ser tan grande como el Layout padre puede permitir

Si utiliza el ratón para arrastrar el marco de un control en el diseñador entonces lo que sucede depende del control y el Diseño.

En la mayoría de los casos el valor predeterminado establecido por el Diseñador se wrap_content y ignorará cualquier intento que haga para dimensionar interactivamente un control. De hecho, en la mayoría de los casos tratando de cambiar el tamaño de forma interactiva un control no cambia el diseño: ancho o el diseño: altura propiedades. Sin embargo, dependiendo de la disposición en uso podría aparecer para cambiar el tamaño del control debido a la configuración de otras propiedades de diseño - más de esto cuando tratamos con particulares tipos de diseño.

El punto es que el diseño: la anchura y el diseño: la altura no son necesariamente las únicas propiedades que controlan el tamaño final que aparece de un control.

Una cosa es bastante seguro - si usted desea establecer un tamaño fijo para un control luego tienes que escribir los valores en la ventana de Propiedades.

Unidades

Si usted va a entrar en un tamaño fijo o una ubicación, entonces tenemos que saber cómo hacerlo. Android es compatible con seis unidades.

Dos están relacionados a los píxeles:

px - píxelesEsta es la unidad que es más tentador usar la primera vez que empezar a crear una aplicación, ya que por lo general tiene un dispositivo de prueba en mente con un tamaño de pantalla en particular y resolución. Esto no es una buena idea si usted quiere que su aplicación se vea más o menos lo mismo que los cambios de resolución de pantalla.

dp - píxeles independientes de la densidadEsta es la unidad más utilizada, ya que se ajusta a la resolución de la pantalla. Si el dispositivo tiene una pantalla con 160 píxeles por pulgada entonces 1DP es el mismo que 1px. Si el número de píxeles por pulgada entonces el cambio dp a cambios de relación px en la misma proporción. Por ejemplo, a 320 píxeles por pulgada 1DP es el mismo que 2px.El punto es que mediante el uso de píxeles independientes de la densidad puede mantener los controles del mismo tamaño que los cambios de resolución.

Observe que esto no compensar el tamaño de la pantalla. Si se mantiene el número de píxeles fijos y el doble de la resolución luego las mitades de tamaño de la pantalla. Un control en la pantalla especificada en px entonces mostrar a la mitad de su tamaño original. Un control especificado en dp exhibiría en su tamaño original pero ocupan el doble de la inmobiliaria pantalla.

El punto es que el uso de dp le protege frente a las pantallas de cambiar su resolución, no su tamaño físico.

Si especifica tamaños en dp entonces su disposición tendrá el mismo aspecto en una tableta de 7 pulgadas, no importa lo que la resolución que tiene.

Además de las medidas basadas en píxeles también hay tres unidades del mundo real:

mm - milímetros

en - pulgadas

pt - puntos de 1/72 de pulgadaLos tres trabajan en términos del tamaño de la pantalla y el número de píxeles utiliza un control está relacionado con la resolución de pantalla. Si la pantalla tiene 160 píxeles por pulgada entonces 1/160 en = 1 px y así sucesivamente.Tenga en cuenta que una vez más estas unidades le protegen contra cambios de resolución, pero no cambios en el tamaño de la pantalla real. Su botón puede ser de 1 pulgada de ancho en todos los dispositivos, pero la cantidad de la pantalla se usa hasta depende del tamaño de la pantalla del dispositivo tiene.

El peligro en el uso de unidades del mundo real es que usted puede ser que también especificar un número fraccionario de píxeles y terminar con una pantalla mirando desordenado.

La unidad final que también se relaciona con píxeles, pero está ligado a la preferencia tamaño de la fuente del usuario:

sp - escala píxeles independientesEsto funciona como la unidad dp en que se escala con la resolución del dispositivo sino que también se escala por la preferencia de tamaño de la fuente a los usuarios por defecto.Si el usuario define una fuente mayor preferencia tamaño todos los valores de SP se escalan hasta igualar.

¿Cuál debe utilizar?Simple - uso dp a menos que tenga una buena razón para no hacerlo, porque esto por lo menos significa que si has probado tu interfaz de usuario en un dispositivo del tamaño de x que debería funcionar razonablemente en todos los dispositivos de tamaño x, no importa lo que la resolución.

Por defecto Android Studio a trabajar en dp cuando se introduce un valor sin una unidad o cuando interactivamente el tamaño o mover un control.

Un control es sólo una caja

En lo que se refiere a un diseño de un control es sólo un rectángulo.

Su tamaño está dado por layout_width y layout_height y estos se puede ajustar mediante el control o, más frecuentemente, por la Disposición.

Una vez que el diseño conoce el tamaño del control se puede colocar de acuerdo a las normas que ha establecido el uso de las propiedades de la distribución.

Si quieres saber la posición de que un control se le ha asignado, puede utilizar sus propiedades getTop y getLeft.Esto le da la posición de la esquina superior izquierda del rectángulo del control. Usted puede calcular dónde las otras esquinas están utilizando getWidth y getHeight, pero para hacer las cosas más fáciles también hay getRight y getBottom.

Tenga en cuenta que la posición de la esquina superior izquierda del rectángulo es siempre relativa a la Disposición es en - es decir, la posición no es una posición de la pantalla absoluta.

También vale la pena saber que los controles también son compatibles con el relleno y algunos márgenes de apoyo Distribución.

El relleno es un espacio muerto en el interior del control que actúa como un espacio entre el borde del control y su contenido.

Márgenes y no todos los márgenes de apoyo Diseños, están muertos-espacio fuera de un control que se puede utilizar para agregar espacio entre los controles.

Tenga en cuenta que el relleno es una propiedad del control y el margen es una propiedad de diseño. Puede ajustar cada margen o material de relleno a la izquierda, derecha, arriba o abajo de forma individual o para un solo valor para todos ellos.

En teoría de relleno se utiliza para poner el espacio que rodea el contenido de un control, pero también se puede utilizar simplemente para hacer que el control más grande cuando sus dimensiones se establecen para envolver su contenido.Por ejemplo. el botón de la izquierda tiene cero relleno y el de la derecha tiene un acolchado de 30DP todo.

Del mismo modo márgenes se utilizan para poner espacio alrededor de un control, pero que pueden ser utilizados para posicionar un control con relación a otro o a su contenedor - esto es cómo funciona el RelativeLayout. Por ejemplo, se puede ver que el botón inferior se posiciona en el RelativeLayout ajustando sus márgenes.

Gravedad

La gravedad es a menudo considerado como misterioso, en parte por su nombre y en parte porque a menudo hay dos propiedades de gravedad.

Básicamente gravedad sólo establece donde en un diseño dinámico algo está posicionado.

Configuración simple gravedad son:

superior

fondo

izquierda

derecho

centro

center_vertical

center_horizontal

El significado de todo esto es obvio - el objeto sólo se mueve a la posición especificada. Sin embargo, las cosas se complican un poco si, por ejemplo, intenta establecer un objeto para mostrar a la izquierda cuando el tamaño de su contenedor ha sido adaptada para ajustarse, es decir, lo que ya es lo más a la izquierda y la derecha, ya que puede ser .

También puede configurar múltiples opciones de gravedad.Por ejemplo, puede establecer izquierda y derecha al mismo tiempo, y esto sólo se centra el objeto horizontalmente.

Lo que hace que la gravedad aún más complicado es que hay ajustes que cambian el tamaño del objeto afectado:

llenar

fill_vertical

fill_horizontal

En cada caso el objeto crece para llenar la dimensión especificada.

También hay dos gravedades de recorte:

clip_vertical

clip_horizontal

estos trabajos con la parte superior, inferior, izquierda y derecha para recortar un objeto para encajar el contenedor.Por ejemplo, si establece la gravedad para arriba y clip_vertical entonces el objeto se colocará en la parte superior del contenedor y su borde inferior se recortará.

La mayoría de las veces usted sólo tiene que utilizar los ajustes de gravedad como centro o superior. Si intenta utilizar combinaciones complicadas entonces las cosas no suelen funcionar como se podría esperar.

La complicación final, que de hecho resulta ser bastante sencilla, es que los controles tienen una propiedad de la gravedad y Distribución de proporcionar una propiedad layout_gravity.

La diferencia es muy simple. La propiedad gravedad establece lo que sucede con el contenido de un control y la layout_gravity establece cómo se posiciona el control que el contenedor Layout.

Por ejemplo, si tiene un botón y establecer su propiedad gravedad al principio luego se trasladó el texto en el botón para alinearse con la parte superior.

Si, por el contrario, se establece layout_gravity de Button al principio todo el botón se mueve hacia la parte superior del contenedor Layout.

Tenga en cuenta que no todos los diseños proporcionan una propiedad layout_gravity a sus controles secundarios.

El FrameLayout

El FrameLayout es el más simple de todos los diseños.

Realmente no hace mucho para posicionar los controles que contiene. Su uso está destinado a albergar un solo control, es decir, lo que realmente se limita a actuar como un marco alrededor de un control.

Si se coloca un FrameLayout en el diseño entonces usted descubrirá que en el Diseñador parece estar formado por nueve áreas:

Estas áreas corresponden a los nueve lugares que se pueden crear mediante el establecimiento de diseño: la gravedad de pares simples de valores - la parte superior izquierda, superior central, arriba a la derecha y así sucesivamente.

Si se le cae un control en uno de los rectángulos entonces su diseño: la propiedad gravedad se ajustará para realizar él exhibición en el área correcta de la FrameLayout. Usted puede usar esto para posicionar varios controles en el mismo FrameLayout, notar que si el tamaño total cambia los diferentes controles bien pueden solaparse.

Si dos controles se superponen en un FrameLayout luego se dibujan en el orden en que se agregaron. En otras palabras, el último añadido se dibuja en la parte superior de los otros.

Este aspecto de la FrameLayout hace útil si desea mostrar los múltiples controles y cambiar entre los cuales uno es visible.En pocas palabras todos los controles en el FrameLayout y seleccionar uno que sea visible mediante su propiedad visible.

Más comúnmente un FrameLayout se utiliza simplemente como un marcador de posición para un componente de una disposición que no está especificado hasta algún tiempo después. Por ejemplo, si usted hace uso de un Fragmento, consulte Presentación de Fragmentos Android ,

para crear parte de una interfaz de usuario o leer en una lista de cosas para mostrar, a continuación, a menudo se necesita un recipiente para el nuevo componente que esté presente en su diseño estático. Un FrameLayout hace el trabajo muy eficiente.

Use un FrameLayout cuando se necesita el diseño más simple que contendrá uno o un pequeño número de componentes sin necesidad de mucho en la forma de colocación o el tamaño.

LinearLayout

El siguiente diseño tenemos que considerar es el LinearLayout.

Esto es un diseño simple que puede ser utilizado para hacer una gran parte del trabajo básico de la organización de una interfaz de usuario.

En Android Estudio LinearLayout aparece dos veces en la paleta - una vez como una vertical y una vez como un LinearLayout horizontal. La diferencia, sin embargo, es sólo el valor de la propiedad a la orientación horizontal o vertical.

Puede utilizar un LinearLayout como el diseño base y sustituir el nombre predeterminado RelativeLayout que Android Studio proporciona o se puede colocar un LinearLayout dentro del RelativeLayout.

Reemplazando un diseño con otro no es tan fácil como parece porque perderás todos los controles ya posicionados cuando se elimina el primer diseño. Si edita el archivo XML para utilizar un diseño diferente, entonces no podría perder el control, pero las cosas se complican si el nuevo diseño no admite el mismo conjunto de propiedades de diseño - que suele ser el caso.

Android Estudio realmente no quiere que usted utilice cualquier diseño que no sea el RelativeLayout como el contenedor inicial y por lo que no le permite eliminarlo en un intento de reemplazarlo. Si usted realmente desea utilizar otra cosa entonces no tienes más remedio que editar el archivo XML directamente.

El LinearLayout horizontal actúa como contenedor fila y una verticales actos LinearLayout como un contenedor de columna.Puede utilizar LinearLayouts anidados para construir algo que se parece a una mesa - pero si esto se pone muy complicado que es mejor usar un TableLayout.

Si se coloca un LinearLayout en el RelativeLayout entonces se puede posicionar como cualquier otro control. Si a continuación, colocar otros controles dentro de ella entonces van a apilar horizontalmente para formar una fila o verticalmente para formar una columna.

Esto suena fácil, pero hay un montón de maneras de utilizar un LinearLayout.

Por ejemplo, si pones una horizontal y una vertical en el LinearLayout RelativeLayout entonces cómo se comportan depende de lo que se propuso su layout_width y layout_height a. Si lo ajusta a wrap_content entonces los dos Layouts actúan como un panel horizontal y vertical de los controles, es decir, puede mover todos los controles como un bloque.

Las cosas se ponen más interesantes cuando se anidan uno LinearLayout dentro de otro para crear una tabla.

Por ejemplo, puede crear un teclado estilo calculadora anidando tres LinearLayouts horizontales dentro de una sola LinearLayout vertical. Es decir, coloque un LinearLayout vertical en la pantalla y luego coloque tres LinearLayouts horizontales dentro de ella. Dentro de cada LinearLayout horizontal colocar tres botones. Si tiene dificultades para hacer este uso de la ventana Árbol de componentes para asegurarse de que los componentes están anidados correctamente.

Esto es más fácil disponer de utilizar el RelativeLayout. El botón de final se acaba de colocar en el LinearLayout vertical y forma una fila de todos los suyos.

No hay mucho más que decir sobre el uso de LinearLayout aparte de una vez de empezar a usarlo y luego tiende a ser el que usted piensa de utilizar con demasiada frecuencia. Es muy atractivo el uso de un LinearLayout como un dispositivo de agrupamiento cada vez que necesite una fila o columna de los controles.

Layout_weight

Hay un último misterio de la LinearLayout para discutir, layout_weight.

Esta es una propiedad de diseño que sólo el LinearLayout apoya.

Si asigna un layout_weight a cualquiera de los controles en un LinearLayout entonces los controles se ajustan en tamaño para llenar cualquier espacio no utilizado en proporción a su peso.

La parte realmente importante de esta descripción es "el espacio no utilizado". Lo que pasa es que Android calcula primero el diseño ignorando cualquier asignación de peso.Esto significa que los controles se establecen en los tamaños especificados. A continuación, el sistema determina qué espacio no se utiliza en el LinearLayout que contiene. Este se distribuye entre los controles que tienen valores distintos de cero de layout_weight en proporción a su peso.

Por ejemplo, supongamos que tenemos un LinearLayout horizontal con tres botones todo listo para wrap_content. La pantalla se ha hecho girar para proporcionar una gran cantidad de espacio no utilizado para el ejemplo:

Se puede ver que hay una gran cantidad de espacio no utilizado a la derecha. Si ahora nos fijamos el diseño de la primera Button: peso a 1, que se asignará a todos que el espacio no utilizado:

Si ahora configurar la disposición del segundo de Button: peso a 1, entonces el espacio no utilizado será compartida entre los dos primeros botones por igual:

Se puede adivinar lo que sucedería si ahora ponemos el diseño de la tercera Button: peso a 1 - el espacio sería compartida por igual y los tres botones sería del mismo tamaño. Si, sin embargo, el primer botón se le dio un peso de 2 a continuación, el espacio no utilizado sería compartida en la relación 2: 1: 1 y así sucesivamente.

Más interesante aún, ¿qué crees que pasaría si ha asignado un ancho fijo para el tercer botón?

La respuesta es simple.

Si el diseño de la tercera Button: peso es cero, entonces se ajusta a la anchura especificada y los otros dos botones obtener el espacio no utilizado - por ejemplo estableciendo el tercer botón de 350dp da:

Sin embargo, si el tercer botón tiene un diseño: establece entonces es probable que cambiar su anchura, ya que obtiene una parte del espacio no utilizado al igual que los otros botones de peso.

En otras palabras, cuando se establece una disposición distinta de cero: peso un control puede cambiar su tamaño, incluso aunque haya establecido un tamaño específico para ello.

Esto nos lleva a la idea de "tamaño medido" y "tamaño real".En el caso del tercer botón de su tamaño medido es 350dp pero si su trazado: peso no es cero, entonces su tamaño real en la pantalla será diferente - que utilizará parte del espacio no utilizado.

Cuando se trabaja con componentes de código de las propiedades getWidth y getHeight le darán el ancho real y la altura del control. Las propiedades getMeasuredWidth y getMeasuredHeight le dará el ancho y la altura medido antes se ha realizado ningún ajuste por el Diseño.

Por último, vale la pena señalar que si usted quiere estar seguro de que los tres botones son del mismo tamaño que tiene que establecer sus anchos para 0DP y peso a 1 (o el mismo valor).

¿Por qué es necesario?

Al configurar el ancho a cero todo el espacio no se utiliza y el sistema será dividido en partes iguales entre cada uno.

También puede ajustar su anchura hasta cierto valor mínimo constante y luego dejar que el mecanismo de acción con cargo a peso el espacio no utilizado.

RelativeLayout

El RelativeLayout es el favorecido por Android Studio.

Es un componente de diseño complejo y sofisticado y usted puede pensar que usted debe preferir más simples componentes de diseño, si es posible. Por ejemplo, usted a menudo puede utilizar un número de LinearLayouts para hacer el trabajo de un solo RelativeLayout.

La regla más comúnmente citado es que usted debe tratar de diseñar la interfaz de usuario usando el menor número de diseños. En particular profundo anidación, de disposiciones, es decir, un diseño dentro de otro, las cosas lentas abajo porque el sistema tiene que cavar profundamente en cada capa de diseño y esto puede tomar un montón de trabajo.

La regla es:

Prefiero un diseño sofisticado superficial a un profundo nido de Diseños simples.

Y RelativeLayout es el más sofisticado de todos.

Generalmente, usted puede reemplazar un conjunto de LinearLayouts anidadas con un RelativeLayout.

Para un diseño tan capaz, RelativeLayout hay pocos propiedades de diseño. Estos se dividen en dos grupos:

propiedades relacionadas con el posicionamiento de la control con respecto al contenedor padre 

propiedades relacionadas con el posicionamiento relativo a otro control.

Al menos uno de los controles en el diseño tiene que ser posicionado en relación al contenedor principal para indicar la posición del resto de la Disposición. Sin embargo, cualquier número de controles puede ser posicionado en relación con el contenedor principal.

Los parámetros RelativeLayout son presentados y organizados por la ventana Propiedades de forma ligeramente diferente a la forma en que son representados como constantes en el XML o en código. Esta descripción se aplica a la forma en Android Estudio les presenta. Consulte la documentación para el XML o constantes programáticas.

La alineación del bordeEl principio es que se puede especificar la alineación de cualquier par de bordes, uno en el padre y uno de cada niño.Esto moverá el control secundario para que sus líneas de borde con el borde de los padres, por ejemplo, el borde superior al borde superior. Si especifica dos pares de bordes entonces usted puede cambiar el tamaño del control, así como la colocación de la misma. Por ejemplo, la parte superior a arriba y abajo a abajo hace que el control de niño de la misma altura que la de los padres.

Disposición PadresLas propiedades de diseño de los padres son: alignParent arriba, izquierda, abajo, derecha

Estos alinear el borde correspondiente del control con la de la RelativeLayout padres.

Por ejemplo: el establecimiento de alignParent a izquierda mueve el lado izquierdo del control para el lado izquierdo de la matriz.

Esto funciona sin ningún tipo de cambio de tamaño del control.

Si selecciona dos alineaciones opuestas, superior e inferior o izquierda y derecha, a continuación, tanto los bordes se mueven y el control cambia de tamaño.

Para ajustar alignParent a izquierda y derecha produce ejemplo:

Así como la alineación de los bordes también se puede alinear con el centro de la matriz. La propiedad centerInParent puede ajustarse a cualquiera de los dos, horizontal, vertical y simplemente centros de control tal como se especifica.

Disposición de los componentesLa propiedad alignComponent puede ajustarse a cualquiera de las ocho posibles pares de arriba, abajo, izquierda y derecha.

El primero indica el borde del control secundario que se alinea con el borde del control primario especificado por el segundo.Por ejemplo superior: parte inferior fija borde superior del niño para que coincida con el borde inferior del control de los padres. Para cada posible par de alineaciones se tiene que especificar el id del control de los padres. Android Studio ayuda a hacer esto mediante la presentación de una lista desplegable de controles posibles que se podrían utilizar para el posicionamiento hacia abajo.

Al igual que en el caso de la alineación con el diseño de los padres puede especificar la alineación de dos bordes por ejemplo izquierda y derecha y esto cambia el tamaño del control de niño a ser el mismo que el control de los padres.

También hay una opción de alineación de línea de base que se alinea la línea de base de texto en el control de los padres y el niño.

Tenga en cuenta que los mapas de Android Estudio de las propiedades que se configuran utilizando el Diseñador de un conjunto más complicado de propiedades XML que usted necesita saber acerca de si va a cambiar el diseño en clave o editar manualmente el código XML. Por ejemplo, si usted coloca Button2 manera que su borde inferior esté alineada con el borde superior de Button1 esta muestra en la ventana de la propiedad como parte inferior: la parte superior, pero en el XML usted encontrará

android:layout_above="@+id/button"

En la mayoría de los casos es más fácil dejar Diseñador generar las propiedades subyacentes o utilizar la ventana Propiedades para establecer ellos, pero es importante saber que hay un nivel más bajo conjunto de propiedades. Para buscarlas en los RelativeLayout.LayoutParams encontrar documentación.

Compensaciones de margenHasta el momento lo único que podemos hacer es alinear pares de bordes.

¿Cómo se especifica posiciones exactas relativas a otro control o el padre?

La respuesta es utilizar el patrón común de establecer los márgenes del control. Si alinea los bordes superiores, pero establece un margen superior de 10DP en el niño y luego la parte superior del control secundario será 10DP más bajo que el control de los padres.

Así que la alineación del borde se utiliza para especificar la dirección relativa de un control a otro y de los márgenes establecidos dan exactamente lo offset.

RelativeLayout Y El DiseñadorCon todo esto entendido ahora se puede ver cómo el diseñador le permite generar un RelativeLayout. Al mover un control en torno a la superficie de diseño del otro mando o la disposición de los padres más cercano está seleccionado como el padre de utilizar para el posicionamiento, los bordes más cercanos se utilizan para la alineación y que el margen se establece en la distancia entre el padre y el niño.

Esto funciona bien, pero a veces puede ser difícil conseguir el Diseñador de escoger el control o el diseño como se mueve un control alrededor. Siempre se puede utilizar la ventana Propiedades para establecer manualmente este si resulta demasiado difícil establecer de forma interactiva.

Observe también que si arrastra y el borde de un control cerca de la alineación con el borde de otro control, entonces el resultado será justo que el borde está alineado y el control cambia

de tamaño. Por ejemplo, si arrastra el lado derecho de un control con el tamaño correcto de la presentación y en el ancho de los cambios de control. Este comportamiento puede confundir a los principiantes con el diseñador, ya que parece ser posible cambiar el tamaño de los controles arrastrando un borde, pero la mayoría del tiempo el control vuelve a su tamaño original cuando se suelta. Por supuesto que sólo cambia de tamaño cuando el borde que está arrastrando las líneas con un borde correspondiente en otro control.

si se entiende la forma en que la RelativeLayout funciona entonces mediante el Diseñador es mucho más fácil y de hecho usando RelativeLayout para crear una interfaz de usuario compleja es más fácil

¿Qué son los de inicio y fin?

Si nos fijamos en la ventana Propiedades, verá algunos parámetros Disposición adicional con inicio y final como parte de su nombre. Si nos fijamos un poco más de cerca estos se refieren a empezar y terminar bordes.

En API 17 se agregó una nueva función para permitir el diseño para tener en cuenta el sentido de la disposición. En el uso normal con Layout_Direction establecer a izquierda a derecha, entonces el borde de inicio es el mismo que el borde izquierdo y el borde final es el mismo que el borde derecho. Si Layout_Direction es de derecha a izquierda y luego empezar que es correcto y al final se deja. Por ejemplo, puede establecer startpadding para controlar el relleno a la izquierda oa la derecha dependiendo de la dirección de diseño establecido.

Tenga en cuenta que esto sólo funciona para la API de 17 en adelante y Diseñador no parece mostrar que, a pesar de que establece las propiedades de inicio y fin a los mismos valores que las propiedades de izquierda y derecha equivalentes.

Resumen

Se pueden utilizar diferentes contenedores de diseño para crear interfaces de usuario. Cada diseño tiene sus propias instalaciones de cómo se colocan y dimensionados controles secundarios. 

Los más importantes son LinearLayout, RelativeLayout y FrameLayout. 

Cada diseño tiene su propio conjunto de propiedades de diseño para controlar el posicionamiento y el tamaño de un control. Controles secundarios tienen una instancia de la clase propiedades de diseño de decir la Disposición cómo posicionar y tamaño ellos. 

Propiedades de diseño se prefijan siempre con layout_ en el XML y escritos como el diseño: en la ventana Propiedades. 

Todos los diseños de apoyar el diseño: la anchura y el diseño: la altura. 

Puede especificar la posición usando un número de diferentes unidades, pero en la mayoría de los casos de uso de densidad dp píxeles independientes ya que esto

funciona de la misma manera en las pantallas del mismo tamaño, pero diferentes resoluciones. 

En lo que se refiere al diseño de un control es sólo un wdith rectángulo de altura colocado usando la parte superior ya la izquierda. 

Todos los controles tienen propiedades de relleno que especifican espacio adicional en torno al contenido del control. 

Algunos diseños proporcionan diseño: propiedades de los márgenes que marcan el espacio extra alrededor de la parte exterior del control. 

Gravedad simplemente establece la sencilla colocación de un objeto - por ejemplo, arriba, abajo, derecha, izquierda. Cada control tiene una propiedad de la gravedad, que establece la posición de su contenido - por ejemplo, el texto de un botón. Algunos Disposición a tener un posicionamiento: la propiedad gravedad que establece cómo se posicionará un control. 

El FrameLayout es el más simple de todos los Layouts y sólo tiene el diseño: la gravedad para el posicionamiento. En la mayoría de casos se mantiene un único control y se utiliza con mayor frecuencia como un marcador de posición. 

El LinearLayout puede utilizarse para organizar los controles como una fila o una columna. 

Diseños complejos pueden ser creados por los nidos de LinearLayouts dentro entre sí para producir una columna o una fila o filas o columnas. Esto ha resultado en la LinearLayout siendo los más utilizados. 

Así como la gravedad, la LinearLayout también es compatible con la especificación del peso de un control.Después de que el tamaño medido de cada control está determinado por el diseño, el espacio no utilizado restante se asigna a los controles en las mismas proporciones que sus pesos asignados. 

El RelativeLayout es el más complejo de los diseños y se puede utilizar para crear casi cualquier interfaz de usuario. 

El principio general es tratar de seleccionar un diseño que resulta en la anidación más pequeña de los envases de diseño. En general, es mejor utilizar una sola RelativeLayout lugar de LinearLayouts profundamente anidadas. 

El RelativeLayout puede parecer complicado o difícil de usar en el Diseñador por la forma en propiedades se establecen y desarmar al mover los controles alrededor. Si usted entiende los principios, entonces es mucho más fácil de usar. Al mover un control del borde más cercano en otro control o la RelativeLayout contienen se establecen para ser alineados y una propiedad margen se establece en la distancia entre ellos. 

Usted puede cambiar el tamaño de los controles utilizando el Diseñador pero sólo arrastrando en un borde y alineándola con la misma ventaja sobre otro control. Es decir, usted puede hacer los controles del mismo tamaño pero no se puede establecer un control a un tamaño arbitrario. 

El Diseñador simplifica las propiedades de diseño que se muestran en la ventana de propiedades y los asigna a un conjunto más amplio de propiedades en el archivo XML generado. 

Inicio y propiedades finales se han introducido para manejar una especificación de dirección de diseño.Para un diseño de izquierda a derecha start = izquierda y al final = derecha. Para un diseño de derecha a izquierda start = derecha y al final = izquierda.

6. Aventuras Android - Ciclo de Vida y EstadoUna de las cosas que usted tiene que acostumbrarse a la hora de programar para una plataforma móvil es que su aplicación se puede apagar y reiniciar sin mucho aviso.Tienes que aprender a lidiar con esta existencia de arranque y parada y de que, por una aplicación para Android, es una vida dura tratando de mantenerse con vida.

Aventuras Android con Android Estudio

Contenido

1. Primeros pasos con Android Estudio

2. La actividad y el interfaz de usuario

3. La construcción de la interfaz de usuario y una calculadora App

4. Controles básicos y Eventos

5. Contenedores de diseño

6. Ciclo de Vida y Estado

7. Spinners

8. Pickers

9. IU Gráficos A Deep Dive

10. ListView y adaptadores  

Fragmentos

11. Presentación de Fragmentos

12. Fragmentos y XML

13. Fragmento Y Actividad Trabajando Juntos

14. Gestión de Fragmentos

15. Diálogos personalizados utilizando DialogFragment

16. Clases de diálogo en el DialogFragment

17. Un Proyecto NumberPicker DialogFragment

18. ViewPager

También si usted está interesado en la creación de plantilla personalizada ver:

Proyectos a Medida En Android Estudio

Vida y Estado

La mayoría de los programadores están acostumbrados a la idea de que su aplicación se iniciará por el usuario, utiliza y luego termina. Si la aplicación se reinicia entonces es por lo general hasta al usuario cargar cualquier contexto que necesitan - documentos, etc. A veces una aplicación tiene para retener automáticamente la información del estado de una ejecución a. Por ejemplo, un juego puede no perder de vista que un usuario había llegado a - que el nivel y la puntuación - pero esto es casi tan complicado como las cosas se ponen.

Para una aplicación que se ejecuta en un dispositivo móvil las cosas son muy diferentes. La propia naturaleza del dispositivo significa que cualquier aplicación puede ser interrumpido en cualquier momento por una llamada telefónica entrante o al usuario hacer una llamada telefónica. Hasta cierto punto, esta necesidad de aplicación "interrumpible" ha sido tomado por los sistemas operativos de teléfonos móviles como un principio más general. Android, por ejemplo, para evitar que su aplicación que se ejecuta sólo porque necesita la memoria o quiere salvar la vida de la batería. Incluso se termina y se reinicia la aplicación si se requiere una reconfiguración medios.

Por ejemplo, como descubrimos en el capítulo anterior, si el usuario cambia la orientación del dispositivo, entonces su aplicación está terminada y se reiniciará. Esto no es un reinicio desde cero porque el sistema guarda y restaura alguna información de estado automáticamente, pero exactamente cómo funciona todo esto es algo que tenemos que averiguar.

La conclusión es que cuando se programa bajo Android - y la mayoría de otros sistemas operativos móviles - usted tiene que preocuparse por el ciclo de vida de su aplicación y hay que tomar medidas para garantizar que se preserva su estado por lo que puede parecer al usuario que nada ha sucedido - a pesar de que la aplicación efectiva ha sido golpeado en la cabeza y eliminados antes de ser arrastrado de nuevo a continuar desde donde estaba.

El ciclo de vida de un App

Los diferentes estados que una aplicación para Android puede ser en y las transiciones entre ellos puede parecer complicado al principio - eso es porque lo son. Si usted todavía está pensando en términos de una aplicación de escritorio que se inicia, se ejecuta y está terminado por el usuario este nivel de complejidad puede parecer innecesario - y quizá lo sea. Sin embargo estas son las reglas que tenemos que jugar por.

La clase de actividad tiene un conjunto de controladores de eventos reemplazables para cada uno de los estados. Éstos trabajan en parejas - horquillado los tres tipos de estado de aplicación.

En el nivel más exterior hay

onCreate y OnDestroy - Soporte de toda la vida de la aplicación. Este par se llama cuando la aplicación se carga en memoria o descarga de la memoria. Estos dos soporte de toda la vida útil de una actividad. Cuando se carga primero la onCreate se activa y cuando la aplicación está dispuesto de OnDestroy se activa. Usted tiene claramente a utilizar estos dos para la instalación y destruir y los recursos que son necesarios para toda la vida útil de la aplicación - aunque en la práctica las cosas puede ser más sutil. El sistema puede detener la aplicación sin llamar a la OnDestroy y puede reiniciar la aplicación de activar un evento onCreate.

onStart y OnStop - soporte de cualquier período que la aplicación es visible. Podría ser que la aplicación está detrás de decir un cuadro de diálogo modal. La aplicación es visible, pero no la interacción con el usuario. Este par de eventos puede ser disparado varias veces durante todo el tiempo de vida de la aplicación. Aplicaciones simples se ignoran en su mayoría los eventos OnStart y OnStop porque la aplicación está todavía en la memoria y no pierde ningún recurso o estado. El uso principal de onStart y OnStop es dar a la aplicación una oportunidad para monitorear cualquier cambio que pudiera afectar a la misma, mientras que no interactúa con el usuario. Para confundir el asunto aún más también hay en el evento onRestart que se produce antes del evento onStart pero sólo si ésta no es la primera vez que la aplicación ha disparado el onStart - es decir se trata de un verdadero reinicio.

onResume y onPause - Soporte del período que la aplicación está en primer plano y la interacción con el usuario.De nuevo este par de eventos puede ocurrir varias veces durante toda la vida útil. El evento onResume se produce cuando la aplicación está en el primer plano y hacer su trabajo habitual. El evento se produce onPause whent que el usuario cambia de distancia a otra aplicación, por ejemplo.

El enfoque sencillo

En este punto, usted tiene todo el derecho a confundirse.

Tantos cambios de estado y qué hacer en cada uno?

Las cosas principales que preocuparse es el reinicio completo de su aplicación que desencadena una OnDestroy y un onCreate. Este es el único que destruye el estado actual de la aplicación - los otros son simplemente oportunidades para su aplicación para reducir la carga en el sistema o para guardar algunos datos de usuario por si acaso. A medida que el OnDestroy suele ser sólo una oportunidad para limpiar los recursos para evitar fugas, esto significa que la mayoría de aplicaciones simples en realidad sólo tienen que entregar el evento onCreate.

Sin embargo, es tentador pensar que este arranque y la parada es justo como una aplicación de escritorio que se termina y luego el usuario decide utilizar de nuevo cuando está bien FOF la aplicación se ejecute fuera como si se estuviese ejecutando por primera vez. En el caso de una aplicación para Android que esto no es lo que el usuario espera en absoluto. Su aplicación puede ser resuelto por el sistema sin que el usuario lo sepa nada al respecto. Cuando el usuario intenta acceder a su aplicación de nuevo que por lo general esperan que continuar desde donde lo dejaron.

Puede ser un reinicio completo en lo que a ti respecta, pero el usuario acaba de cambiar a otra aplicación durante unos minutos y espera encontrar la suya como lo dejaron.

Nótese también que a menudo estos eventos se producen en secuencias. Por ejemplo, una aplicación que acaba de recibir el evento onPause es probable que vaya a recibir el evento OnDestroy porque el sistema lo eliminará para liberar memoria decir. Es un error tratar de pensar demasiado en las secuencias de acontecimientos y pedir que uno debe hacer cualquier inicialización en particular o limpiar.

Basta con pensar en el estado en que su aplicación se está moviendo en y colocar el código necesario en ese controlador de eventos.

Explorador del ciclo de vida

No hay mejor manera de sentirse cómodo con el ciclo de vida y sus acontecimientos de escribir un programa de demostración corta que muestra cuando se producen.

Iniciar una nueva aplicación de la actividad en blanco Android, aceptando todos los valores predeterminados, y lo llaman ciclo de vida y luego aceptar todos los valores predeterminados para empezar a trabajar rápidamente.

En el editor de diseño quitar la cadena "Hola Mundo" y colocar una TextView en la superficie de diseño. Siguiente cambiar su tamaño de forma que ocupe la mayor parte de la zona - que puede ser difícil de conseguir que se ajusta al tamaño y eliminar su entrada de texto predeterminado.

El código es bastante fácil el único truco es recordar a llamar a cada uno de los controlador de eventos sistema previsto es que ha anulado. Si usted no hace esto la aplicación simplemente termina cuando lo ejecuta.

El controlador de eventos OnCreate todavía tiene que construir la interfaz de usuario, pero ahora tenemos una referencia al objeto Java que representa el TextView:

private TextView textView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); textView = (TextView) findViewById(R.id.textView); textView.append("Create\n"); } @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); textView = (TextView) findViewById(R.id.textView); textView.append("Create\n"); }

El resto del programa simplemente anula cada uno de los controladores de eventos, a su vez, llama al controlador de eventos originales y luego agrega un mensaje de texto al TextView:

@Override protected void onStart() { super.onStart(); textView.append("Start\n"); }

@Override protected void onPause() { super.onPause(); textView.append("Pause\n"); } 

@Override protected void onResume() { super.onResume(); textView.append("Resume\n"); }

@Override protected void onStop() { super.onStop(); textView.append("Stop\n"); }

@Override protected void onRestart() { super.onRestart(); 

textView.append("Restart\n"); }

@Override protected void onDestroy() { super.onDestroy(); textView.append("Destroy\n"); }

Una especie muy simple y aburrida de programa - si usted no desea escribir en o copiar y pegar entonces usted lo puede encontrar en el CodeBin .

Probándolo

Si ahora ejecutamos este programa se puede utilizar para saber cuándo los eventos del ciclo de vida suceden.

Puede que se sorprenda al saber que la primera vez que ejecuta el programa se obtiene

Si se piensa en ello por un momento esto no es razonable que se carga la aplicación, se hace visible y asumiendo el primer plano.

Si intenta otras cosas como presionar la tecla Inicio y seleccionar otra aplicación entonces verás otras secuencias de eventos - pero por supuesto sólo cuando se reanudará la aplicación del ciclo de vida.

Por ejemplo, pulsando la tecla de inicio, a continuación, muestra el administrador de tareas pulsando largo la tecla de inicio y volver a seleccionar los resultados de aplicaciones en: Pause, Stop ya que la aplicación se retira del primer plano y luego en Reiniciar, Inicio, curriculum vitae como se carga la aplicación, se convierte en visible y luego vuelve a sonar el primer plano e interactúa con el usuario.

Usted puede intentar otras acciones fuera, pero hay una cosa que debes probar - cambiar la orientación. Si está utilizando el emulador a continuación, pulse Ctrl-F11. Cuando la orientación de la pantalla cambia verá que la TextView se ha despejado y Crear, se han añadido en Inicio, Reanudar.

Esto se debe a que cuando se cambia la orientación de la aplicación está totalmente detenida y luego completamente reiniciado, es decir, es como si la aplicación se está ejecutando desde cero por primera vez.

Esta declaración es casi cierto - pero no del todo.

Estado de retención - El Bundle

Cuando cambie la orientación de su aplicación se detiene y reinicia. Cuando esto sucede, la TextView se restablece a su estado predeterminado cuando se carga la aplicación. Sin embargo, esta no es la historia completa. El sistema hace retener el estado de los elementos de interfaz de usuario que pueden ser modificados por el usuario y los restaura automáticamente cuando se inicia la aplicación.

Esto es lo que el parámetro savedInstanceState en el controlador de eventos onCreate se trata:

protected void onCreate( Bundle savedInstanceState) {

Un paquete es un conjunto de pares de valores clave y cuando la aplicación se detiene por el sistema que utiliza para guardar los valores almacenados en los elementos de interfaz de usuario que pueden ser modificados por el usuario.Almacena id pares / valor y cuando se reinicia la aplicación del paquete se utiliza para inicializar los valores de los elementos de la interfaz correspondientes.

Observe que si el usuario deja su aplicación mediante la eliminación de lo que dice en la lista de aplicaciones recientes entonces el savedInstanceState se destruye y la aplicación realmente empezar de nuevo.

En otras palabras savedInstanceState sólo restaura la interfaz de usuario cuando la aplicación se ha detenido por el sistema.

También vale la pena notar que la restauración trabajará para un diseño alternativo cargado debido a un cambio de configuración. Por ejemplo, se restaurará el estado a una versión del paisaje de un diseño, así como la versión original retrato.

En este punto, probablemente te preguntes por qué el objeto TextView no fue restaurada por el sistema cuando se hizo girar entonces dispositivo?

La respuesta simple es que un objeto TextView no está diseñado para la interacción del usuario - que se supone que sólo se utilizará para mostrar las etiquetas de texto estático y por lo que el sistema no guardar una restaurarlo.

Usted puede ver guardar la automática y restauración en la acción si se agrega un campo de entrada EditarTexto en la superficie de diseño del explorador del ciclo de vida. Ahora si introduce algún texto en el campo EditarTexto que se mantendrá si se gira el dispositivo. Sin embargo, si mantiene pulsada la tecla de inicio, eliminar la aplicación y vuelva a iniciarlo de nuevo, verá que el campo EditarTexto está en blanco de nuevo.

El texto en el campo EditarTexto en la parte inferior de la pantalla se conserva durante una rotación de la pantalla.

Guardando Datos adicionales UI

Hay un montón de maneras de salvar el estado de una aplicación a medida que se inicia y se detiene por el sistema.Una de las más simples es ue el objeto Bundle que utiliza el sistema.

El sistema se activa el evento onSaveInstanceState cuando está a punto de agregar datos al paquete y guárdelo. Si desea guardar algunos datos adicionales todo lo que tienes que hacer es reemplazar el controlador de eventos por defecto.

Por ejemplo, supongamos que desea guardar y restaurar los datos en el TextView en el explorador del ciclo de vida.Primero tienes que guardar los datos:

@Override protected void onSaveInstanceState(

Bundle savedInstanceState){ savedInstanceState.putCharSequence( "myText",textView.getText()); super.onSaveInstanceState(savedInstanceState); }

Tenga en cuenta que guardamos el contenido de texto del objeto TextView como el valor y utilice la tecla "myText". En la mayoría de los casos, sería mejor crear una cadena constante para la clave.

Ahora para recuperar los datos y colóquelo en el TextView tenemos que cambiar el controlador de eventos onCreate:

@Override protected void onCreate( Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); textView = (TextView) findViewById(R.id.textView); if (savedInstanceState != null) { textView.setText( savedInstanceState.getCharSequence("myText"));textView.setText( savedInstanceState.getCharSequence("myText")); } textView.append("Create\n"); } } textView.append("Create\n"); }

Esto comienza en la forma habitual pero ahora comprueba si savedInstanceState tiene ningún dato. Si es así recuperamos el texto almacenado usando la tecla "myText".

También puede reemplazar la función onRestoreInstanceState de la misma forma si desea mantener el controlador de eventos onCreate buscando simple.

Hay establecer y obtener métodos para una amplia gama de tipos de datos estándar y con frecuencia todo lo que necesita hacer para asegurarse de que su aplicación mantiene su estado entre reinicios del sistema es utilizar el objeto savedInstanceState Bundle. Tenga en cuenta que usted puede ahorrar datos arbitrarios y no sólo los datos para el diseño.

Como un ejercicio que ahora puede volver a ICalc introducido en el capítulo anterior y hacer su exhibición y valor actual persisten a través de una rotación de pantalla.

Gestión del Estado Avanzada

Para completarlo, vale la pena señalar que hay muchos más enfoques para mantener el estado. Más tarde, usted tendrá que descubrir la forma de almacenar gran cantidad de datos de los usuarios a nivel local para la persistencia a largo plazo y esto es a menudo suficiente para implementar la administración del estado a través de un cambio de configuración.

También puede optar por quedarse con un objeto de su elección mediante el onRetainNonConfigurationInstance ().Todo lo que tienes que hacer es anular esta función para que devuelva el objeto que desea conservar. El sistema almacenará entonces este objeto para usted y lo devolverá a usted cuando usted lo solicita mediante getLastNonConfigurationInstance () que devuelve el objeto que se guardó por última por el sistema.

El objeto puede ser tan complejo como quiera, pero no tratar de salvar a un objeto del sistema como una actividad o una vista. Esto sólo se traduce en pérdidas de memoria.

El último en asegurarse de que las cosas sucedan como quiera que para manejar la configuración cambia a ti mismo.

Usted puede hacer esto haciendo un cambio en el manifiesto.Si usted hace esto, entonces le corresponde a usted para hacer los cambios necesarios cuando el onConfigurationChanged incluso se produce. Por ejemplo, podría optar a animar botones y otros objetos de interfaz de usuario en nuevas posiciones o simplemente ignorar la necesidad de volver a configurar por completo.

7. Aventuras Android - Spinners y recolectoresPágina 1 de 3

Trabajar con Android Studio hace que la construcción de la interfaz de usuario fácil con un editor interactivo, pero usted todavía tiene que encontrar la manera de manejar las cosas no es tan bueno. En los próximos dos capítulos de nuestro libro electrónico en Android el camino más fácil, nos fijamos en los hilanderos y recolectores, el siguiente paso después de los botones y controles de texto.

Aventuras Android con Android Estudio

Contenido

1. Primeros pasos con Android Estudio

2. La actividad y el interfaz de usuario

3. La construcción de la interfaz de usuario y una calculadora App

4. Controles básicos y Eventos

5. Contenedores de diseño

6. Ciclo de Vida y Estado

7. Spinners

8. Pickers

9. IU Gráficos A Deep Dive

10. ListView y adaptadores 

Fragmentos

11. Presentación de Fragmentos

12. Fragmentos y XML

13. Fragmento Y Actividad Trabajando Juntos

14. Gestión de Fragmentos

15. Diálogos personalizados utilizando DialogFragment

16. Clases de diálogo en el DialogFragment

17. Un Proyecto NumberPicker DialogFragment

18. ViewPager

También si usted está interesado en la creación de plantilla personalizada ver:

Proyectos a Medida En Android Estudio

Spinners son lo que se conoce como listas desplegables o algo similar en otros interfaces de usuario. Permiten al usuario elegir entre una lista de posibles temas.

Recogedores son similares a spinners en que permiten al usuario elegir un elemento, pero en este caso los elementos se definen más estrechamente - una fecha, una hora o un número. De los recolectores de la fecha y hora recolectores son bastante conocidos, pero para un conjunto impar de razones el número selector de largo se ha descuidado.

Vamos a empezar con la Spinner.

El Spinner Y El ArrayAdapter

El spinner presenta un conjunto de alternativas para el usuario y les permite seleccionar uno. Poner un Spinner en que el proyecto es tan fácil como usar la caja de herramientas en el diseñador pero no se puede salir sin algún Java para hacer que todo funcione. En particular, es necesario definir la lista de elementos que el Spinner mostrará cuando el usuario lo activa. La primera vez que coloca un Spinner en la superficie de diseño que muestra texto ficticio. Nuestra primera tarea es reemplazar el texto de relleno con una lista real de alternativas.

La clase más simple de cosas para mostrar al usuario una lista de elementos de texto y que bien podría pensar que la manera más directa de hacer esto es utilizar una matriz de cadenas - y es lo contrario. En el caso de UI widgets que muestran listas de cosas para Android tiene un mecanismo mucho más general para hacer frente a los diferentes tipos de cosas que usted puede mostrar. Widgets que muestran listas de cosas en general, trabajar con un ejemplo de un "adaptador". Un adaptador básicamente toma una lista de los objetos y las convierte en algo que se puede mostrar en el widget. En general se puede crear adaptadores personalizados que hacer cosas inteligentes con listas de objetos de su propia para que

muestren adecuadamente. En la mayoría de casos, sin embargo puede llegar a funcionar con sólo usar los adaptadores integradas proporcionadas.

En el caso de la spinner la elección más habitual de adaptador es el ArrayAdapter. Esto tiene una gran variedad de objetos de ningún tipo y los hace adecuados para la exhibición llamando a su método toString (). Mientras el método toString () produce lo que quieres ver en el Spinner entonces todo debería funcionar. En el caso de una matriz de cadenas de llamar al método toString () en cada elemento de la matriz que podría parecer una exageración, pero es el precio que debemos pagar para construir mecanismos que pueden hacer frente a las situaciones más complicadas.

Así que el plan de acción es crear una matriz de cadenas con los artículos que queremos mostrar, usar esto para inicializar un objeto ArrayAdapter y luego coloque la ArrayAdapter al Spinner.

La creación de la matriz es fácil:

String[] country = {"Canada", "Mexico", "USA"};

El constructor ArrayAdapter puede parecer que ser complicado. Parece aún más complicado porque ArrayAdapter utiliza los genéricos para que pueda especificar el tipo de cada elemento de la matriz. Si usted no ha utilizado los genéricos antes, todo lo que necesita saber es que en lugar de crear un adaptador serie especial para cada tipo de matriz, un IntArrayAdapter, un StringArrayAdapter y así sucesivamente, usted simplemente tiene que especificar el tipo como <int> o <String> cuando se utiliza el tipo ArrayAdapter.

Por ejemplo, para crear un ArrayAdapter para una matriz de cadenas que utilizaría:

ArrayAdapter<String> stringArrayAdapter= new ArrayAdapter<String>( constructor parameters );

El patrón es el mismo para todos los constructores y para diferentes tipos de matriz.

Hay un buen número de constructores ArrayAdapter, pero todos necesitan un poco de información básica. Necesita saber el contexto actual, por lo general esto, el diseño que se utilizará para mostrar la lista y el conjunto de elementos de datos.

La única dificultad es el diseño que se utilizará para mostrar la lista. Esto suena como un montón de potencial de trabajo duro hasta que descubre que el sistema ofrece algunas disposiciones estándares básicos que usted puede utilizar. En nuestro caso el diseño es:

android.R.layout.simple_spinner_dropdown_item

Observe que este es un número entero que determina el recurso diseño de usar.

Poniendo todo esto junto da:

ArrayAdapter<String> stringArrayAdapter= new ArrayAdapter<String>( this, android.R.layout.simple_spinner_dropdown_item, country);

Y si usted se está preguntando qué país es, se le ha olvidado que definimos un llamado país Array cadena anterior.

El paso final es para especificar el ArrayAdapter para utilizar en la Spinner. Primero tenemos que recuperar el Spinner y entonces podemos usar su methiod setAdapter:

Spinner spinner= (Spinner)findViewById(R.id.spinner); 

spinner.setAdapter(stringArrayAdapter);

Si se agrega todo el código al controlador de eventos onCreate el resultado es:

@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); String[] country={"Canada", "Mexico", "USA"}; ArrayAdapter<String> stringArrayAdapter= new ArrayAdapter<String>( this, android.R.layout.simple_spinner_dropdown_item, country); Spinner spinner = (Spinner) findViewById(R.id.spinner); spinner.setAdapter(stringArrayAdapter); }

Si ejecuta el programa verá:

Manejo de la selección

La siguiente pregunta es ¿cómo se descubre que el usuario ha realizado una selección?

La respuesta simple es que tenemos de la conexión de los eventos del hilandero. Como siempre hay tres posibles maneras de hacer esto -

crear una subclase de AdapterView.OnItemSelectedListener y luego una instancia

implementar la interfaz AdapterView.OnItemSelectedListener como parte de la actividad

utilizar una clase anónima

De los tres la clase anónima parece la más fácil porque Android Estudio generará los métodos de interfaz para usted.Si usted comienza a escribir la siguiente línea y utilizar el autocompletado:

AdapterView.OnItemSelectedListener onSpinner= new AdapterView.OnItemSelectedListener(){

entonces Android Estudio generará:

AdapterView.OnItemSelectedListener onSpinner = new AdapterView.OnItemSelectedListener() { @Override public void onItemSelected( AdapterView<?> parent, View view, int position, long id) { } @Override public void onNothingSelected( AdapterView<?> parent) { } }

También agrega una importación para AdapterView. Usted todavía tiene que añadir un punto y coma al final, sin embargo.

Si usted no utiliza la función de autocompletar entonces usted podría tener que escribir todo en - incluyendo la importación.

Se puede ver a la vez que hay que aplicar dos controladores de eventos:

onItemSelected - activa cuando el usuario selecciona un elemento

onNothingSelected - desencadenado cuando el Spinner no tiene partidas o el usuario anula la selección de todos los artículos

También podría preguntarse cuál es el <?> Se encuentran en el código generado?

Ambos eventos son genéricos y trabajan con una gama de diferentes tipos. El <?> Es un comodín tipo que esencialmente permite a cualquier tipo que se utilizará. Por ejemplo List <?> Es una lista de cualquier tipo. Por supuesto, el tipo real no se conoce hasta el tiempo de ejecución y por lo que cada elemento de la lista es tratado como un tipo de objeto y su hasta usted para echarlo a algo más específico. 

onItemSelected

Veamos el controlador de eventos onItemSelected con más detalle:

public void onItemSelected( AdapterView<?> parent, View view, int position, 

long id) { } 

¿Qué es este AdapterView que ha aparecido de repente?

Todos los componentes visibles de la interfaz de usuario corresponden a ver los objetos de un tipo u otro. Un AdapterView es el objeto View que corresponde a uno de los elementos que se muestran en la Spinner que el ArrayAdapter está representada en. Puede utilizar el AdapterView pasado al controlador de eventos decir modificar el aspecto del elemento que se muestra.

El parámetro de vista es simplemente el hijo de la AdapterView que fue hecho clic - un artículo puede estar compuesto por más de un Ver artículo.

Por último, el parámetro de posición int y la larga Identificación proporcionan la posición de la vista que se hizo clic en el adaptador y la fila Identificación del elemento seleccionado. Usted puede llenar un Spinner desde una base de datos - en este caso la fila Identificación da el número de fila de base de datos - que no es necesariamente la misma que su posición en el Spinner. Para un simple ArrayAdapter la posición y el ID son las mismas.

En la mayoría de los casos, el único parámetro que será interesa es la posición int que le da la opción al usuario seleccionado.

Por ejemplo, colocar un TextField en la superficie de diseño y cambiar el controlador de eventos onItemSelected para que diga:

@Override public void onItemSelected( AdapterView<?> parent, View view, int position, long id) { TextView myTextView = (TextView) findViewById(R.id.textView); myTextView.setText(Integer.toString(position)); }

Todo lo que está sucediendo es que el parámetro de posición se muestra en la Vista de Texto.

Finalmente conectar el objeto de eventhandling al Spinner tenemos que añadir que el uso de su setOnItemSelectListener

spinner.setOnItemSelectedListener(onSpinner);

Poniendo todo esto junto da la nueva onCreate:

@Override protected void onCreate( Bundle savedInstanceState) { super.onCreate(savedInstanceState); 

AdapterView.OnItemSelectedListener onSpinner = new AdapterView.OnItemSelectedListener() { 

@Override public void onItemSelected( 

AdapterView<?> parent, View view, int position, long id) { TextView myTextView = (TextView)findViewById(R.id.textView); myTextView.setText(Integer.toString(position)); } 

@Override public void onNothingSelected( AdapterView<?> parent) { } }; 

setContentView(R.layout.activity_main); String[] country = {"Canada", "Mexico", "USA"}; ArrayAdapter<String> stringArrayAdapter= new ArrayAdapter<String>( this, android.R.layout.simple_spinner_dropdown_item,country);Spinner spinner = (Spinner) findViewById(R.id.spinner); spinner.setAdapter(stringArrayAdapter); spinner.setOnItemSelectedListener(onSpinner); }

Si ahora ejecuta el programa, verá algo como:

La posición representada corresponde al elemento de la matriz que ha sido seleccionado - a contar desde cero por supuesto.

La mayoría de las veces es suficiente sólo para tener el número de índice del elemento seleccionado pero el objeto AdapterView tiene algunos métodos que permiten conseguir el artículo seleccionado.

Si desea revisar el elemento seleccionado se puede utilizar la posición de índice de la ArrayAdapter original o incluso la matriz original Cadena - pero estos no están generalmente disponibles para el controlador de eventos. Así retrive el elemento que utilizaría el método getItemAtPosition.

Por ejemplo, para mostrar el nombre del país deberá modificar la llamada setText a:

myTextView.setText( (String) parent.getItemAtPosition(position));

Tenga en cuenta que el elemento seleccionado se devuelve como un tipo de objeto y hay que echarlo antes de poder hacer nada con ella.

Hay una serie de otros métodos que se pueden utilizar para recuperar información o manipular el elemento seleccionado, pero para aplicaciones más simples la getItemAtPosition es todo lo que necesitas saber.

ArrayAdapter De Recursos

Ajuste de los contenidos de la Spinner utilizando una matriz de cadenas en código es una buena manera de ver cómo funciona el Spinner pero no es la forma en que suele ocurrir.

Android ofrece un sistema integral de recursos - Cuerdas, imágenes y un montón de archivos XML. La idea es que se puede producir versiones personalizadas de aplicación que con sólo cambiar el recurso de archivos, es decir, sin tener que modificar el código.

Por ejemplo, en el caso de un Spinner podría configurar un recurso que fue una matriz de cadenas que proporcionó la lista de elementos que se mostrarán. Si a continuación desea crear una versión de su aplicación para un mercado extranjero que usted podría conseguir la lista traducida y ha creado un recurso en el nuevo idioma.

Los recursos son una gran idea y que deben utilizarlas con todas las cuerdas fijas y datos fijos en general. Hasta ahora los ejemplos han tendido a evitar recursos para hacer las cosas más simples, pero para un Spinner lo que necesita saber cómo codificar un recurso de tipo Alfa y utilizarlo.

Android estudio tiene un buen apoyo de recursos, pero en algunas zonas es deficiente. Por ejemplo, en un mundo ideal el sistema ayudaría a crear una cadena o cadena de recursos matriz, pero por el momento sólo va tan lejos. Si bien no ayudará a crear un recurso de cadena que no hace nada por una matriz de cadenas y no tenemos más remedio que trabajar con el archivo XML.

Es decir - en el momento en Android estudio sólo proporciona ayuda

Encuentra el strings.xml archivo en el directorio res / valores y abra el archivo strings.xml. Añádase a esto la definición de la matriz de la secuencia:

<string-array name="SpinnerList"> <item>Canada</item> <item>Mexico</item> 

<item>USA</item> </string-array>

El significado del XML es evidente y esta es la ventaja de un lenguaje de marcado legible por humanos.

Si usted ha explorado los recursos utilizando la ventana de Recursos que aparece cuando se selecciona la opción de tres puntos en la ventana de propiedades usted puede preocuparse de que este nuevo recurso es decir SpinnerList, no aparece. La razón es que en la actualidad Android estudio no apoya la asignación, la edición o creación de matrices de Cuerda que no sea de forma manual. Sin embargo haciendo uso del nuevo recurso es bastante fácil.

Para crear un ArrayAdapter de un recurso que necesita para hacer uso de un método estático de la clase ArrayAdapter - createFromResource. Esto sólo necesita especificar el contexto, el identificador de recursos y la disposición Spinner. Todo lo que tienes que hacer es reemplazar la creación de stringArrayAdapter

ArrayAdapter<CharSequence> stringArrayAdapter= ArrayAdapter.createFromResource( this, R.array.SpinnerList, android.R.layout.simple_spinner_dropdown_item);  

Con este cambio todo funciona como antes, pero ahora para cambiar los elementos que aparecen en el Spinner simplemente editar el archivo XML.

Cambio de la lista

Hay un montón de cosas más avanzadas que se pueden hacer con Spinners pero estos no se encuentran que a menudo - sobre todo cuando se trata de construir una experiencia de usuario personalizada.

La única cosa que no ocurre a menudo es la necesidad de cambiar dinámicamente la lista de elementos. Hay muchas variaciones en esto, pero básicamente lo que puede hacer es cambiar la matriz de cadena y luego llamar al método notifyDataSetChange del adaptador. Por ejemplo, si desea cambiar de México, es decir, un elemento, a Groenlandia se debería utilizar:

country[1]="Greenland"; stringArrayAdapter.notifyDataSetChanged();

El ArrayAdapter también tiene un complemento, limpiar, remover y un método de inserción que se puede utilizar para modificar los datos subyacentes, pero para que esto funcione el objeto la celebración de los datos tiene que ser modificable.No se puede modificar una matriz de cadenas de esta manera. Lo que necesita es un ArrayList.

Si cambia la declaración del país a:

ArrayList<String> country=new ArrayList<String>( Arrays.asList("Canada", "Mexico", "USA"));

A continuación, puede añadir "Groenlandia" hasta el final de los elementos mediante:

stringArrayAdapter.add("Greenland");

Siempre puedes averiguar cuántos elementos hay por el método de getCount.

Observe que en este caso el constructor ArrayAdapter utiliza cambios de uno que acepta una matriz a una que acepta una lista de objetos.

¿Cómo modificar una lista de elementos que se crean mediante un recurso?

Esta es una pregunta difícil porque el ArrayAdapter crea una matriz de cadenas para contener los datos que significa que no puede utilizar los métodos que modifican una lista.

Hay un número de maneras de fijar esto para arriba pero la más sencilla es, quizás, para construir su propio ArrayList del recurso:

Resources res=getResources(); ArrayList<String> country=new ArrayList<String>( Arrays.asList( res.getStringArray(R.array.SpinnerList))); ArrayAdapter<String> stringArrayAdapter= new ArrayAdapter<String>( this, android.R.layout.simple_spinner_dropdown_item, country);

Con esta versión del ArrayAdapter puede volver a utilizar el complemento y otros métodos para modificar la lista de elementos.

Conclusión

Hay mucho más que decir sobre el Spinner y cómo personalizarlo pero los métodos que se explica aquí son los más comunes. Si usted no está de acuerdo enviarme un email con una pregunta.

Y si usted se está preguntando qué pasó con Pickers - el próximo capítulo entra en el tema.

Mientras tanto, si usted tiene alguna pregunta sobre lo que hemos cubierto hasta ahora por favor hágamelo saber utilizar los comentarios.

8. Aventuras Android – PickersPágina 1 de 3

Los recolectores son importantes formas de obtener la entrada del usuario, sino que han pasado por muchas revisiones que carecen de documentación simple o directrices cómo usarlos. Trabajar con Pickers - fecha, hora o número - puede ser un lío confuso. Vamos a ver si podemos hacer que todo parezca lógico.

Aventuras Android con Android Estudio

Contenido

1. Primeros pasos con Android Estudio

2. La actividad y el interfaz de usuario

3. La construcción de la interfaz de usuario y una calculadora App

4. Controles básicos y Eventos

5. Contenedores de diseño

6. Ciclo de Vida y Estado

7. Spinners

8. Pickers

9. IU Gráficos A Deep Dive

10. ListView y adaptadores 

Fragmentos

11. Presentación de Fragmentos

12. Fragmentos y XML

13. Fragmento Y Actividad Trabajando Juntos

14. Gestión de Fragmentos

15. Diálogos personalizados utilizando DialogFragment

16. Clases de diálogo en el DialogFragment

17. Un Proyecto NumberPicker DialogFragment

18. ViewPager

También si usted está interesado en la creación de plantilla personalizada ver:

Proyectos a Medida En Android Estudio

Un selector es una "marca" que se puede utilizar para seleccionar una de un conjunto predeterminado de valores.En este sentido, es muy parecido a la Spinner cubierto en laentrega anterior , pero que tiene un conjunto más restringido de opciones. Android es compatible actualmente con tres recogedores de fechas, horas y números generales.

En la actualidad existe un pequeño problema con los recogedores y Android estudio que hace el editor de interfaz de usuario deja de hacer que el DatePicker y en general el uso de Pickers es ligeramente frágil.

El uso de un selector

El primer gran confusión a aclarar es que hay dos maneras de hacer uso de un Picker - como un widget o como un cuadro de diálogo. De los tres recogedores conocidos, el TimePicker y el DatePicker vienen como widgets y como cuadros de diálogo. El NumberPicker sólo se suministra como un widget, pero por supuesto usted puede ponerlo en un cuadro de diálogo si desea.

En la mayoría de los casos es probable que desee crear un cuadro de diálogo y en este caso es necesario utilizar un DialogFragment para envolver el diálogo y gestionar su ciclo de vida. El único problema con esto es que un fragmento es un componente de interfaz de usuario complicada y hay muchas situaciones en las que utilizan el widget prima va a hacer el trabajo lo suficientemente bien.

En resumen, tiene sentido mirar primero los widgets de Picker subyacentes antes de que lleguemos ronda a mirar Diálogos y DialogFragments en un capítulo posterior.

Utilizando TimePicker

TimePicker es un lugar muy fácil para empezar. Si crea un nuevo proyecto Android, llamado TimeAndDate y aceptar todos los valores predeterminados se puede colocar un TimePicker en la superficie de diseño como cualquier otro widget de - no hay necesidad de preocuparse por fragmentos o cuadros de diálogo. Usted puede encontrar el TimePicker en la sección Fecha y hora de la caja de herramientas donde también se encuentra el DatePicker.

Coloque el TimePicker en la superficie de diseño y tamaño y localizar en los términos requeridos. En su configuración por defecto se nota en el diseñador utilizando el Theme.Light estilo y tiene botones para el usuario para ajustar la hora:

Sin embargo, si se ejecuta el programa, suponiendo que usted está apuntando a la última versión de Android podrás ver el más reciente TimePicker Holo estilo:

El estilo Holo es sin duda más fácil de usar ya que el usuario puede usar el tacto para "girar" la selección y llegar a un valor mucho más rápido que en la versión anterior.

Si usted realmente desea presentar el viejo TimePicker estilo, o cualquiera de los otros Pickers, usted tiene que forzar el estilo de ser Theme.Light o cualquiera de los otros estilos del tema. En principio, debería ser capaz de hacer esto utilizando Android de estudio, pero los cambios en el estilo que seleccione en el diseñador sólo cambia lo que se ve en el diseñador y no en la versión final en ejecución. En el momento en que tiene que hacer el cambio de estilo de forma manual mediante la edición de los archivos de recursos XML que controlan.

Estilo y temas en general, es un gran tema que se tratará en profundidad en otro capítulo. No tenga en cuenta por el momento, que gran parte de la documentación se refiere a las versiones earler de Android. La versión actual utiliza el archivo de valores / styles.xml para determinar el estilo utilizado para los niveles anteriores a la API v11. Para v11 y más tarde hay archivos de estilo XML específicos almacenados en directorios llamados valores-VXY donde xy es el número de versión.

Así que si usted está destinada a una audiencia v14 SDK necesita cargar y valores-v14 editar / styles.xml que contiene de forma predeterminada:

<style name="AppBaseTheme" parent="android:Theme.Holo.Light.DarkActionBar"> <!-- API 14 theme customizations can go here. --></style>

Lo que esto significa es que no importa lo que cambia en valores / estilos del programa que se ejecuta utilizará Holo.Light.DarkActionBar.

Sin embargo, si edita el archivo para que diga:

<style name="AppBaseTheme" parent="android:Theme.Light"> <!-- API 14 theme customizations can go here. --></style>

entonces el estilo "clásico" se utilizará y verá:

Para interactuar con el TimePicker todo lo que tiene que utilizar es los métodos get / set para currentHour y CurrentMinute. También puede programáticamente cambiar el modo de hora 12 horas / 24. Observe que el tiempo siempre se devuelve en forma de 24 horas independientemente del modo del widget es.

Por ejemplo, para establecer el TimePicker usarías

TimePicker tp= (TimePicker) findViewById(R.id.timePicker); tp.setIs24HourView(true); tp.setCurrentMinute(10); tp.setCurrentHour(13);

La única tarea que queda es encontrar la manera de descubrir entonces el usuario ha seleccionado un tiempo.Usted puede proporcionar un botón que el usuario tiene que hacer clic para confirmar la nueva hora.

Por ejemplo, si coloca un botón y una TextView en la superficie de diseño, añadir el siguiente controlador de eventos clic de los botones:

public void doButtonClick(View e){ TextView tv= (TextView) findViewById(R.id.textView); TimePicker tp= (TimePicker) findViewById(R.id.timePicker); tv.setText(tp.getCurrentHour().toString() + ":"+tp.getCurrentMinute().toString()); }

y recuerde poner Click propiedad de Button a doButtonClick entonces usted tiene una manera para que el usuario ajuste la hora.

En la mayoría de los casos, la parte difícil en el uso de un selector no se lo crea o conseguir los datos de ella, pero en el procesamiento de esos datos en un formulario que su programa puede utilizarlo. En este caso, simplemente convertir el tiempo en un poco con formato representación de cadena.

Actualización del tiempo

¿Qué hay de conseguir una actualización cada vez que el usuario cambia el TimePicker?

La solución a esto es escribir un controlador de eventos para un evento OnTimeChanged. Como siempre, se trata de una cuestión de ya sea la aplicación de la interfaz OnTimeChangedListener en la Actividad o como una clase anónima. Utilizando Android Estudio la clase anónima es el método más sencillo. Si escribe en

TimePicker.OnTimeChangedListener OnTimeChanged= new TimePicker.OnTimeChangedListener() {

utilizando la finalización de código y luego al final Android Estudio generará un talón:

TimePicker.OnTimeChangedListener OnTimeChanged= new TimePicker.OnTimeChangedListener() { @Override public void onTimeChanged( TimePicker view, int hourOfDay, int minute) { } }

Se puede adivinar que cuando el tiempo se cambia por el usuario el método onTimeChanged se llama y el TimePicker que desencadenó el evento se pasa como vista, y su hora y minuto configuración como hourOfDay y minutos.

Todo lo que queda es configurar el controlador de eventos utilizando el método setOnTimeChangedListener.

Por ejemplo, para transferir el nuevo tiempo para el TextView utilizado en el ejemplo anterior se debería utilizar:

TimePicker.OnTimeChangedListener OnTimeChanged = new TimePicker.OnTimeChangedListener() { @Override 

public void onTimeChanged( TimePicker view, int hourOfDay, int minute) { TextView tv = (TextView) findViewById(R.id.textView); tv.setText(Integer.toString(hourOfDay) + ":" + Integer.toString(minute)); } };

Y usted necesita añadir:

tp.setOnTimeChangedListener(OnTimeChanged);

a OnCreate para asociar el objeto OnTimeChanged y su método de gestión de eventos con el TimePicker.

Ahora bien, si se ejecuta el programa, verá el TextView cambiar cada vez que el usuario modifica la TimePicker por cualquier método.

El programa completo, incluyendo el código para el botón y el controlador de eventos se muestra a continuación y también se puede descargar desde el CodeBin :

import android.os.Bundle; import android.app.Activity; import android.view.Menu; import android.view.View; import android.widget.TextView; import android.widget.TimePicker; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); TimePicker tp = (TimePicker) findViewById(R.id.timePicker); tp.setIs24HourView(true); tp.setCurrentMinute(10); tp.setCurrentHour(13); tp.setOnTimeChangedListener(OnTimeChanged); } 

public void doButtonClick(View e) { TextView tv = (TextView)findViewById(R.id.textView); TimePicker tp = (TimePicker) findViewById(R.id.timePicker); tv.setText(tp.getCurrentHour().toString() + ":" + tp.getCurrentMinute().toString()); } 

TimePicker.OnTimeChangedListener OnTimeChanged = new TimePicker.OnTimeChangedListener() { @Override public void onTimeChanged( TimePicker view, int hourOfDay, int minute) { TextView tv = (TextView) findViewById(R.id.textView); tv.setText(Integer.toString(hourOfDay) + ":" + Integer.toString(minute)); } }; } 

DatePicker

Una vez que haya visto el TimePicker en acción hay muy poco que añadir a cubrir el DatePicker.

El único gran problema es que en el momento de escribir el DatePicker y el widget del calendario no rinden en el diseñador. Si se coloca un DataPicker en la superficie de diseño, verá el mensaje:

Todavía puede utilizar el diseñador para colocar una DatePicker y puede utilizar la ventana Propiedades para modificarla pero arrastrar y tamaño no puede el widget de forma interactiva.

Para ver el DatePicker en acción simplemente iniciar un nuevo proyecto llamado Fecha y aceptar todos los valores predeterminados. Coloque una DatePicker en la superficie de diseño en la esquina superior izquierda - usted no será capaz de editar después de colocarlo por el insecto.

Para ver la vista de tres estándar "spinner" del DatePicker es necesario agregar al final del evento OnCreate:

DatePicker dp = (DatePicker) findViewById(R.id.datePicker); dp.setCalendarViewShown(false);

Al igual que con la TimePicker, el DatePicker se muestra en estilo Holo cuando se genera para las API de 11 o más.

Puede mostrar el estilo más antiguo editando sea el style.xml en valores-v11 y / o valores-v14 para que diga:

<style name="AppBaseTheme" parent="android:Theme.Light"> <!-- API 14 theme customizations can go here. --></style> 

Si usted hace esto o si apunta a una API anterior lo que verá es:

Como alternativa se puede optar por mostrar también un calendario completo en cualquiera de los estilos estableciendo CalendarViewShown true y se puede quitar los hilanderos estableciendo SpinnersShown false.

Además de jugar con la forma en la DatePicker se ve, también se puede establecer y obtener todas las partes de una fecha con:

DayOfMonth

Mes

Año

También puede configurar y ver las fechas de máximo y mínimo que el widget mostrará.

Puede configurar un botón para que el usuario pueda ajustar la fecha al igual que con la TimePicker o puede utilizar el evento OnDateChanged para rastrear el valor. Hacer esto sigue los mismos pasos que para el evento OnTimeChanged pero con una pequeña diferencia - no existe un método setOnDateChangedListener. En cambio, hay un método init que se puede utilizar para ajustar la fecha y el controlador de eventos.

Por ejemplo, si agrega un TextView a la parte inferior de la superficie de diseño y el código siguiente para el controlador de eventos a continuación, puede ver la fecha cambia cada vez que el usuario realiza un cambio:

DatePicker.OnDateChangedListener onDateChanged= new DatePicker.OnDateChangedListener() { @Override public void onDateChanged( DatePicker view, int year, int monthOfYear, int dayOfMonth) { TextView tv = (TextView)findViewById(R.id.textView); tv.setText(Integer.toString(monthOfYear) + "/"+Integer.toString(dayOfMonth)+ "/"+Integer.toString(year) ); } };

Para configurar el DatePicker es necesario agregar al final del evento OnCreate:

dp.init(2014,4,2,onDateChanged);

que fija el año, el mes y el día y el controlador de eventos.

Si se ejecuta la aplicación, verá:

Esto le indica a la vez que los meses se numeran comenzando con Jan en cero no 1. La solución es añadir uno al número de meses.

El programa completo, también en el CodeBin es:

import android.os.Bundle; import android.app.Activity; import android.view.Menu; import android.widget.DatePicker; import android.widget.TextView; 

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); DatePicker dp = (DatePicker) findViewById(R.id.datePicker); dp.init(2014,4,2,onDateChanged); dp.setCalendarViewShown(false); dp.setSpinnersShown(true); } 

DatePicker.OnDateChangedListener onDateChanged= new DatePicker.OnDateChangedListener() { @Override public void onDateChanged( DatePicker view, int year, int monthOfYear, int dayOfMonth) { TextView tv = (TextView)findViewById(R.id.textView); tv.setText(Integer.toString(monthOfYear+1) + "/"+Integer.toString(dayOfMonth)+ "/"+Integer.toString(year) ); } }; }

Number Picker

Usted sabe que el NumberPicker va a haber problemas cuando note que está en la sección de Expertos de la caja de herramientas!

En realidad es muy fácil de utilizar y por qué está en la sección de expertos, y no con los otros Pickers, es difícil saber.

Para probarlo se inicia un nuevo proyecto llamado Número y aceptar todos los valores predeterminados.

Para usarlo todo lo que tienes que hacer es seleccionar que es un lugar en la superficie de diseño. Usted, al igual que los otros Pickers, ver una versión diseñada para las API de más edad.

Si ejecuta la aplicación a continuación podrás ver el NumberPicker estilo de la última API que en este caso se ve muy extraño, porque no hay nada cargado en el "spinner".

La razón de esto es que el NumberPicker es un poco más complicado que los otros Pickers en que permite establecer cuáles son las partes del hilandero pantallas.

Hay dos formas distintas en las que se pueden establecer el intervalo que se muestra - como un par de valores mínimos y máximos, o como los valores almacenados en una matriz.

Por ejemplo, si lo que desea el NumberPicker para mostrar 0-9 podría utilizar:

NumberPicker np= (NumberPicker) findViewById(R.id.numberPicker); np.setMaxValue(9); np.setMinValue(0);

Si no desea que el número spinner para envolver puede utilizar

np.setWrapSelectorWheel(false);

Si usted quiere dar al usuario la opción de 0, 10, 20 y así sucesivamente hasta el 90 primero tiene que inicializar una matriz de cadenas de tamaño correcto para estos valores. En este caso la diferencia entre MaxValue y MinValue propiedades 1 da el número de elementos en la lista.

Para crear la matriz necesitamos un sencillo bucle for:

String[] values=new String[10]; for(int i=0;i<values.length;i++){ values[i]=Integer.toString(i*10); }

Una vez que tenemos la matriz de valores para mostrar que se puede asignar a la Picker utilizando su método setDisplayedValues:

NumberPicker np= (NumberPicker) findViewById(R.id.numberPicker); np.setMaxValue(values.length-1); np.setMinValue(0); np.setDisplayedValues(values); 

Usted puede haber notado que la matriz se utiliza para especificar los valores es una matriz de cadenas. Lo que esto significa es que el NumberPicker, a pesar de su nombre, puede permitir al usuario elegir entre una lista de cadenas arbitrarias que se pueden establecer.

Por ejemplo:

String[] values=new String[3]; values[0]="mike"; values[1]="sue"; values[2]="harry"; np.setMaxValue(values.length-1); np.setMinValue(0); np.setDisplayedValues(values);

produce:

Cuando se trata de la recuperación de los datos que se puede utilizar el método getValue que devuelve un entero que es el valor que el usuario escogió si usted no está utilizando una matriz de cadenas para los valores, o si es el índice de la matriz de cadena del valor que el usuario recogido.

Si desea obtener una actualización en vivo del valor que el usuario selecciona usted puede utilizar el evento OnValueChange. El controlador de eventos

public void onValueChange( NumberPicker picker, int oldVal, int newVal)

le proporciona el objeto NumberPicker que el hecho ocurrió el como selector y el índice de los valores antiguos y nuevos. El único problema es conseguir que el valor de la matriz de cadena que define los valores que se muestran lo que probablemente no es accesible desde el controlador de eventos. La solución es utilizar getDisplayedValues del NumberPicker que devuelve una matriz de cadenas de valores.

Por ejemplo, para transferir el valor a una TextView primero hay que definir un objeto de escucha que se puede hacer fácilmente con la ayuda de autocompletado de Android Productora:

NumberPicker.OnValueChangeListener onValueChanged=new NumberPicker.OnValueChangeListener() { @Override public void onValueChange( NumberPicker picker, int oldVal, int newVal) { String[] values=picker.getDisplayedValues(); TextView tv= (TextView) findViewById(R.id.textView); tv.setText(values[newVal]); TextView tv= (TextView) findViewById(R.id.textView); tv.setText(values[newVal]); } 

}; } };

Este utiliza el selector para obtener el conjunto de valores que se muestran a continuación, que se transfiere a la TextView usando el newVal como índice.

Todo lo que necesita hacer para hacer este trabajo es añadir el Listener al NumberPicker:

np.setOnValueChangedListener(onValueChanged);

Ahora, cuando su ejecute el programa de la TextView se actualiza tan pronto como se realiza algún cambio.

Eso es todo lo que hay para el uso básico de la NumberPicker.

Para algunas tareas es mejor para mostrar la antigua NumberPicker estilo. Una vez más todo lo que necesita hacer es hacer el cambio estándar para cualquier otro archivo XML de estilo que son relevantes valores-v14 / styles.xml y.

<style name="AppBaseTheme" parent="android:Theme.Light"> <!-- API 14 theme customizations can go here. --></style>

Si haces lo que te dan es lo que se ve en el diseñador de Android Productora:

Multi-Digit entrada

Por último, si desea crear una entrada de varios dígitos - dicen centenas, decenas, unidades - a continuación, sólo tiene que utilizar tres NumberPickers. Esto es más difícil de lo que parece,

si desea realizar un seguimiento de forma dinámica el valor actual en más de un NumberPicker.

Por ejemplo, para crear una entrada de tres dígitos primero tiene que colocar tres NumberPickers en la superficie de diseño con identificadores numberPicker1, numberPicker2 y numberPicker3.

Usted podría inicializar cada uno de los NumberPickers, a su vez, pero es instructivo utilizar una matriz de NumberPickers para hacer el trabajo:

NumberPicker[] nps=new NumberPicker[3]; nps[0]= (NumberPicker) findViewById(R.id.numberPicker1); nps[1]= (NumberPicker) findViewById(R.id.numberPicker2); nps[2]= (NumberPicker) findViewById(R.id.numberPicker3);

Ahora tenemos una gran variedad de objetos NumberPicker podemos inicializar todos ellos de la misma manera usando un bucle for, pero primero tenemos que la matriz de valores que se utilizará:

String[] values=new String[10]; for(int i=0;i<values.length;i++){ values[i]=Integer.toString(i); }

Como estamos usando 0-9 esto se podría hacer como un índice sin utilizar una matriz, pero esto hace que el ejemplo más general.

Ahora tenemos la matriz de valores que podemos inicializar los NumberPickers:

for(int i=0;i<3;i++){ nps[i].setMaxValue(values.length-1); nps[i].setMinValue(0); nps[i].setDisplayedValues(values); nps[i].setOnValueChangedListener(onValueChanged);}

Nótese que el mismo controlador de eventos se utiliza para todos los NumberPickers. En algunos casos, esta es la manera de hacer las cosas de otra que es mejor tener un controlador de eventos para cada widget.

El siguiente problema pequeño es la forma de actualizar el valor mostrado en un TextView cuando uno de los NumberPickers cambia su valor.

Una vez más la solución más simple para un ejemplo es obtener los valores de cada uno de los NumberPickers utilizando un bucle for:

NumberPicker.OnValueChangeListener onValueChanged=new NumberPicker.OnValueChangeListener() { @Override public void onValueChange( NumberPicker picker, int oldVal, int newVal) { NumberPicker[] nps=new NumberPicker[3]; nps[0]= (NumberPicker) findViewById(R.id.numberPicker1); nps[1]= (NumberPicker) findViewById(R.id.numberPicker2); nps[2]= (NumberPicker) findViewById(R.id.numberPicker3); String temp=""; for(int i=0;i<3;i++){ String[] values=nps[i].getDisplayedValues(); temp=values[nps[i].getValue()]+temp; } TextView tv=(TextView)findViewById(R.id.textView); tv.setText(temp); } TextView tv=(TextView)findViewById(R.id.textView); tv.setText(temp); } }; } };

En este caso no utilizamos cualquiera de los parámetros del método evento simplemente conseguimos los tres NumberPickers y obtenemos sus DisplayValues como una matriz de cadenas y el valor actual utilizando el índice devuelto por getValue.

El único complicado pero es la construcción de la cadena de dígitos que se muestra en la temp. Si no está seguro de lo que está pasando intente cambiar la línea que establece la temperatura para que diga:

temp=temp+values[nps[i].getValue()];

En la jerga de matemáticas La concatenación de cadenas no es conmutativa - en la jerga de programación importa que termina usted se pega algo en una cadena.

Por supuesto, como todos los tres NumberPickers comparten el mismo conjunto de valores que realmente necesitamos sólo para getDisplayedValues vez, pero esto es más general.También es muy obvio que parte del código se repiten y que sería mejor que refactorizar para crear una función para obtener los tres NumberPickers por ejemplo.

Si ejecuta el programa debe ser capaz de alterar lo que se muestra en el TextView de una manera el valor de posición de tres dígitos sensata:

El programa completo, que se encuentra en el CodeBin , es:

package com.example.number; import android.os.Bundle; import android.app.Activity; import android.view.Menu; import android.widget.NumberPicker; import android.widget.TextView; 

public class MainActivity extends Activity { 

@Override protected void onCreate(Bundle savedInstanceState{ super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); 

NumberPicker.OnValueChangeListener onValueChanged=new NumberPicker.OnValueChangeListener() { @Override public void onValueChange( NumberPicker picker, int oldVal, int newVal) { NumberPicker[] nps=new NumberPicker[3]; nps[0]= (NumberPicker) findViewById(R.id.numberPicker1); nps[1]= (NumberPicker) findViewById(R.id.numberPicker2); nps[2]= (NumberPicker) findViewById(R.id.numberPicker3); String temp=""; for(int i=0;i<3;i++){ String[] values=nps[i].getDisplayedValues(); temp=values[nps[i].getValue()]+temp; } TextView tv= (TextView) findViewById(R.id.textView); tv.setText(temp); 

} }; 

String[] values=new String[10]; for(int i=0;i<values.length;i++){ values[i]=Integer.toString(i); }

NumberPicker[] nps=new NumberPicker[3]; nps[0]= (NumberPicker) findViewById(R.id.numberPicker1); nps[1]= (NumberPicker) findViewById(R.id.numberPicker2); nps[2]= (NumberPicker) findViewById(R.id.numberPicker3); for(int i=0;i<3;i++){ nps[i].setMaxValue(values.length-1); nps[i].setMinValue(0); nps[i].setDisplayedValues(values); nps[i].setOnValueChangedListener(onValueChanged);} }

Conclusión

Hay mucho más que decir sobre el Pickers y cómo personalizarlos, pero los métodos que se explica aquí son los más comunes. Si necesita más ayuda enviarme un email con una pregunta.

El mayor omisión aquí es el uso de los recolectores dentro de un DialogFragment. Este es un gran tema que será cubierto en un capítulo posterior.

Mientras tanto, si usted tiene alguna pregunta sobre lo que hemos cubierto hasta ahora por favor hágamelo saber utilizar los comentarios.

Puede descargar el código de los programas de la CodeBin(nota hay que registrarse primero).

9. Aventuras Android - UI Gráficos A Deep Dive

Si quieres ser un buen programador de Android, no sólo lo que necesita saber cómo crear una interfaz de usuario, sino también cómo se crea la interfaz de usuario. Para ser realmente seguro de lo que está haciendo, es necesario comprender algunos de los mecanismos internos del sistema de gráficos Android.

Aventuras Android con Android Estudio

Contenido

1. Primeros pasos con Android Estudio

2. La actividad y el interfaz de usuario

3. La construcción de la interfaz de usuario y una calculadora App

4. Controles básicos y Eventos

5. Contenedores de diseño

6. Ciclo de Vida y Estado

7. Spinners

8. Pickers

9. IU Gráficos A Deep Dive

10. ListView y adaptadores 

Fragmentos

11. Presentación de Fragmentos

12. Fragmentos y XML

13. Fragmento Y Actividad Trabajando Juntos

14. Gestión de Fragmentos

15. Diálogos personalizados utilizando DialogFragment

16. Clases de diálogo en el DialogFragment

17. Un Proyecto NumberPicker DialogFragment

18. ViewPager

También si usted está interesado en la creación de plantilla personalizada ver:

Proyectos a Medida En Android Estudio

Una biblioteca de interfaz de usuario

Hay un montón de diferentes kits de construcción de la interfaz de usuario para Java y otros lenguajes - AWT, Swing, Qt, MFC, WPF y sobre - y usted podría pensar que el dominio de todos ellos sería una tarea difícil, si no imposible. De hecho, es mucho más fácil de lo que parece porque la mayoría de las bibliotecas de interfaz de usuario utilizan el mismo enfoque general y la biblioteca de interfaz de usuario de Android que no parecen tener un nombre no es diferente.

Echemos una mirada cuidadosa a cómo funciona.

Una actividad tiene una ventana de la misma y esto es por lo general toda la pantalla gráfica del dispositivo que se está ejecutando. En otras palabras, una actividad puede permitir que otras clases de Java para dibujar en la pantalla de los dispositivos. Sin embargo, en lugar de simplemente proporcionar acceso directo al hardware gráfico hay un extenso conjunto de clases que hacen que la construcción de una interfaz de usuario y la realización de operaciones de gráficos más fácil.

Antes de ver la gráfica general tenemos que averiguar primero cómo se construye la interfaz de usuario.

The View

La base de todos los componentes de interfaz de usuario y gráficos 2D generales es la clase View.

Esta es una clase de propósito general que tiene montones y montones de métodos y propiedades que determinan cómo se mostrará la entidad widget o otros gráficos que representa.También participa en el sistema de gestión de eventos que significa Vistas pueden responder a eventos.

Hay Ver clases que implementan todos los widgets estándar que usted haga uso de Android en el diseñador de estudio, es decir, el botón, TextView y así sucesivamente.

Cada objeto View tiene un método OnDraw que puede dibujar la representación gráfica de lo que representa en un objeto Canvas, que es esencialmente un mapa de bits con métodos de dibujo.

Lo que pasa es que la actividad llama al método OnDraw de la Vista cuando se necesita actualizar la interfaz de usuario y la pasa un objeto Canvas que luego presta a la pantalla - usted no tiene que preocuparse acerca de cómo el lienzo se vuelve a la pantalla en este nivel. Usted puede pensar en esto como "cada objeto View sabe cómo dibujar a sí misma".

En resumen:

Una actividad puede estar asociada con un objeto View.

Cuando la actividad tiene que dibujar su interfaz de usuario que llama al método Ver los objetos OnDraw ejemplo view.onDraw (lienzo)

El objeto View entonces dibuja en el lienzo lo que necesita para - un botón, texto o lo que sea.

La actividad a continuación, muestra el objeto Canvas en la pantalla.

Una actividad puede estar asociada con una única vista objeto que determina lo que se dibuja en la pantalla. Esto puede parecer un poco limitado, pero, como se verá, está lejos de ser limitada.

setContentView

¿Cómo se establece un objeto View para mostrar en la ventana de Actividades?

La respuesta es que se utiliza el método Actividades setContentView - que es lo que hemos estado haciendo todo el tiempo.

Para ver esto en acción, iniciar un nuevo proyecto Actividades blanco simple y agregue el siguiente código al onCreate:

Button b = new Button(this); setContentView(b);

La primera instrucción crea un objeto Button, que es una subclase de vista, y el segundo establece esto como la vista Actividades.

Si ejecuta este programa lo que se ve es un área gris que ocupa toda la pantalla. Sí, este es el botón! Incluso puedes hacer clic en él aunque, sin controlador de eventos, no pasa nada.

Para hacer que el botón un poco más interesante que podemos personalizarlo estableciendo las propiedades.

Por ejemplo:

Button b = new Button(this); b.setText("Hello Button"); setContentView(b);

Si ejecuta este verá un botón que llena la pantalla con la leyenda "Hola botón".

No te molestes en establecer las propiedades de diseño porque en este momento no hay ninguna disposición en vigor por lo que se ignorarán. ¿Cómo conseguir un diseño en la acción es nuestro siguiente tema.

Layout - ViewGroup

Si una actividad sólo puede mostrar un solo objeto View ¿cómo podemos crear una interfaz de usuario compleja con múltiples botones, textViews y otros widgets?

La respuesta es, y es probable que ya lo adivinó, es que no son objetos de la presentación o ViewGroup que pueden utilizarse para alojar otros objetos View.

Así que en casi todos los casos el objeto View que se asocia con una actividad es una vista de diseño.

Cuando la Actividad pide la vista de diseño para hacer sí mismo, llamando a su método OnDraw la Disposición llama al método OnDraw de cada uno de los Objetos de visión que contiene y los pone juntos para hacer un solo resultado. Por supuesto que también realiza una operación de posicionamiento disposición y el dimensionamiento de la Ver objetos que contiene.

Así que un Layout hace dos cosas:

alberga otros objetos View

que realiza la función de distribución después de la cual toma su nombre.

Para ver esto en acción try:

LinearLayout linLayout=new LinearLayout(this); Button b = new Button(this); b.setText("Hello Button"); linLayout.addView(b); setContentView(linLayout);

La primera instrucción crea un objeto LinearLayout. Esta es una subclase de vista que pueden contener otros objetos de vista y los organiza en una izquierda a derecha o de arriba a abajo de manera dependiendo de la configuración de su propiedad orientación. A continuación, creamos un objeto de botón y luego utilizamos el método addView estándar del LinearLayout para añadirlo a la disposición.

Si ejecuta este programa, verá un botón a la derecha en la parte superior izquierda de la pantalla. Usted puede agregar más botones para ver cómo funciona el diseño lineal por defecto:

Por el momento estamos confiando en la configuración por defecto de los objetos de vista que estamos creando. Sin embargo, en la práctica se puede pasar el tiempo y las líneas de código para establecer todas las propiedades necesarias para crear cualquier interfaz de usuario y el diseño de usted quería.

Ahora ya sabe cómo crear una interfaz de usuario completamente en código. Todo lo que tienes que hacer es crear todos los objetos de widget que necesita, establezca sus propiedades y añadirlos a los objetos de disposición adecuados.

Observe también que un diseño puede contener otras presentaciones y por lo que el conjunto de Ver objetos que componen una interfaz de usuario está estructurado como un árbol - la jerarquía de vistas. Cuando la pantalla se vuelve a dibujar se pide a cada objeto View dibujarse a sí mismo y esto se hace para todos los objetos de vista de la jerarquía de arriba a abajo.

Normalmente la jerarquía Vista se dibuja una sola vez cuando se carga la actividad. Si un área de la pantalla se oscurece por otro gráfico por algún motivo, el volver a dibujarlo inteligente como para no sacar todo el Vista jerarquía. Sólo se vuelve a dibujar Ver objetos que se cruzan con el área invalidada de la pantalla. No hay más que decir sobre esto más adelante.

La jerarquía Ver también participa en la aprobación eventos entre los objetos y en la determinación de qué control tiene el foco actual.

Disposición XML

Hasta el momento los principios del sistema de gráficos son bastante simples.

Todos los mandos o el widget corresponde a un objeto de vista y se puede construir una interfaz de usuario mediante la creación de objetos de vista de código y agregarlos a diseños. Una actividad se basará su Visualizar jerarquía para la pantalla cuando necesita.

OK, esto es cómo crear una interfaz de usuario en el código, pero hasta ahora hemos estado construyendo una interfaz de usuario mediante el Diseñador.

¿Cómo se relaciona esto con la jerarquía View?

El diseñador crea un archivo XML que describe la jerarquía Vista que desea crear. La forma en que esto funciona es bastante obvio. Cada etiqueta en el archivo XML corresponde a un objeto View que le gustaría crear una instancia de.

Por ejemplo:

<LinearLayout> </LinearLayout>

crearía una instancia de un objeto LinearLayout.

Anidación de etiquetas dentro de una disposición indica que la necesidad objeto creado que se añade a la disposición como niños Vistas. Por ejemplo:

<LinearLayout> <Button /> </LinearLayout>

crearía un objeto LinearLayout y un objeto Button y luego agregar el objeto Button al LinearLayout utilizando su método addView.

Se puede ver que el XML captura la idea de la jerarquía Ver perfectamente.

Para establecer las propiedades del objeto todo lo que tienes que hacer es es utilizar los atributos correspondientes en el XML. Por ejemplo para ajustar el texto del botón que utilizaría

<Button android:text="New Button" />

Eso es realmente todo lo que hay que hacer. El XML define una jerarquía de objetos y sus propiedades y el sistema lee el archivo y crea los objetos. Este uso de XML como un sistema de objetos de instancias no es un caso raro.

Por supuesto, el XML creado por el diseñador se parece mucho más complicado que los ejemplos anteriores, pero esto se debe principalmente a que el número de atributos que define. La idea básica sigue siendo la misma.

Teoría de la inflación

La gran pregunta final que responder es ¿cómo el XML se convierten en una jerarquía de objetos reales?

La respuesta a esto es utilizar una "inflado". Para inflar un diseño es jerga de Android para crear instancias de los objetos definidos por un archivo XML.

Normalmente no tiene que llamar a un inflado debido a que el sistema lo hace por usted detrás de las escenas, pero se puede si usted quiere.

Por ejemplo, para inflar un diseño que utilizaría una instancia de la LayoutInflater. Normalmente no crear una instancia de fresco, pero la opción de pedir prestado de THS sistema utilizando getLayoutInflater. Una vez que tenga la LayoutInflater puede utilizar uno de sus muchos métodos inflar para crear una jerarquía Ver objeto según lo especificado por el código XML. El método que use depende de dónde se almacena el código XML. Simplemente puede suministrar un ID de recurso para un archivo XML incluido en el directorio res.

Por ejemplo, para inflar el diseño habitual activity_main.xml se debería utilizar:

LayoutInflater inf = getLayoutInflater(); View myView = inf.inflate(R.layout.activity_main,null); setContentView(myView);

El segundo parámetro de inflado se puede usar para proporcionar un objeto View para actuar como el contenedor raíz para la jerarquía Ver inflado.

Por supuesto esto es totalmente equivalente a la de costumbre:

setContentView(R.layout.activity_main);

que llama a la LayoutInflater y fija la vista en una instrucción.

La única razón por la que a usted le inflar manualmente un diseño XML es si querías hacer algo inteligente como poner un diseño junto con otro o de alguna manera manipular la jerarquía View.

Observe que hay otros tipos de objetos Inflater - por ejemplo, el de inflado Menú pero hace el mismo trabajo de convertir XML a objetos instanciados con las propiedades dadas. Hay también una versión del método de inflado:

inflate(R.layout.activity_main,root, true/false);

que se infle el recurso XML utilizando la raíz como su contenedor a efectos de diseño si el último parámetro es falso y que se sumará la Vista inflado a la raíz si el último parámetro es cierto.

Encontrar objetos View

Uno de los problemas que tenemos que resolver si se quiere trabajar con la jerarquía Ver creado por un inflado es encontrar objetos de vista de la jerarquía.

En el ejemplo donde construimos la jerarquía Ver en código era fácil seguir la pista de un botón o un TextView simplemente manteniendo una referencia a cuando se creó.Un inflado simplemente devuelve la jerarquía Vista sin una manera fácil de conseguir en un objeto particular, por ejemplo un botón.

Una forma de resolver el problema sería la de "caminar" el árbol Vista. Un objeto ViewGroup por ejemplo, un diseño no sólo tiene un método addView pero una serie de métodos que permiten acceder a los objetos que contiene. Cada objeto hijo se le asigna un índice de enteros - Piense en ello como una matriz. El método:

getChildAt(i)

devolverá el objeto secundario en el índice i.

También puede utilizar:

getChildCount()

para averiguar cómo se almacenan muchos objetos secundarios en el contenedor.

El uso de estos métodos puede buscar en la jerarquía del objeto View que quieras, pero ¿cómo saber cuál es?

La respuesta a esta pregunta es que todos los objetos de vista tienen una propiedad id que debe identificarlos por separado. Hay métodos getId y SETID pero por lo general la propiedad ID se establece como parte del archivo XML.

Para evitar tener que llegar a un valor id la manera estándar de crear un id es definir un recurso:

<Button android:id="@+id/my_button"

Cuando el archivo XML se infla el @ + símbolo se interpreta como "crear un recurso". Un Identificación del número entero se genera utilizando el método generateViewId y esto se utiliza tanto para crear la propiedad id y añadir una propiedad my_button al objeto R.id.

Hay mucho más que decir acerca de los recursos, pero por el momento esto es suficiente para entender lo que está pasando.

Lo que todo esto significa es que no sólo se obtiene un valor de id autogenerado, sino también una forma de obtener este valor en la ejecución de código. Usted podría utilizar los métodos getChildAt al paso a través de todos los objetos de vista de la jerarquía, pero es mucho más fácil de usar:

findViewById(R.id.my_button);

que devuelve el objeto en una instrucción.

Cómo construir una interfaz de usuario?

Ahora tiene dos, al menos, los enfoques para la construcción de una interfaz de usuario. Usted puede hacer todo el trabajo en el código o puede crear un diseño de XML.

En la práctica, por lo general es más fácil utilizar el diseñador Android Studio para generar el archivo XML para usted. No obstante, usted puede mezclar los dos enfoques y cambiar una interfaz de usuario "sobre la marcha". Por ejemplo, usted puede cargar una interfaz de usuario de forma implícita o explícita inflar un archivo XML y luego escribir código para crear y añadir otros widgets o incluso eliminar los objetos de vista del diseño. Para quitar Ver objeto sólo tiene que utilizar los métodos removeView o removeViewAt del objeto ViewGroup.

¿Qué más se puede aprender?

En los próximos capítulos tenemos que averiguar sobre fragmentos, cuadros de diálogo y gráficos 2D.

10. Aventuras Android - ListView y adaptadores

ListView es, probablemente, los componentes de interfaz de usuario más comúnmente utilizados y necesarios en una aplicación para Android. No es difícil de usar, pero hay que llegar a enfrentarse con la idea de un "adaptador" y entender lo que está pasando paga dividendos.

Aventuras Android con Android Estudio

Contenido

1. Primeros pasos con Android Estudio

2. La actividad y el interfaz de usuario

3. La construcción de la interfaz de usuario y una calculadora App

4. Controles básicos y Eventos

5. Contenedores de diseño

6. Ciclo de Vida y Estado

7. Spinners

8. Pickers

9. IU Gráficos A Deep Dive

10. ListView y adaptadores 

Fragmentos

11. Presentación de Fragmentos

12. Fragmentos y XML

13. Fragmento Y Actividad Trabajando Juntos

14. Gestión de Fragmentos

15. Diálogos personalizados utilizando DialogFragment

16. Clases de diálogo en el DialogFragment

17. Un Proyecto NumberPicker DialogFragment

18. ViewPager

También si usted está interesado en la creación de plantilla personalizada ver:

Proyectos a Medida En Android Estudio

Por una serie de razones, una de las cosas más comunes que hay que hacer en una interfaz de usuario de Android es para mostrar una lista de las cosas que el usuario puede elegir.

Si está familiarizado con el desarrollo de escritorio entonces usted probablemente piense en las listas que el usuario puede seleccionar de como algo similar a una lista desplegable.Dispositivos Android y portátiles a menudo necesitan algo más que una pequeña lista. Debido al tamaño limitado de la pantalla es a menudo el caso de que el usuario sólo puede mostrar una visión general de un buen número de artículos diferentes. Cuando el usuario selecciona un elemento que se presentan a continuación con más detalles del elemento - una vista de detalles.

Viendo listas y otras colecciones de datos es tan común que Android tiene un mecanismo que hace que sea más fácil.Bueno, hace más fácil una vez que entienda cómo funciona todo.

La idea clave es que para ver una colección cada elemento de la colección tiene algo de cómo se convierte en un objeto View apropiado. Es el objeto View que las pantallas de contenedores para cada elemento de los datos de la colección.

El Adaptador

Que exhibe una colección de artículos tiene una serie de similitudes no importa lo que la colección de elementos son o lo que el contenedor.

El recipiente tiene diversas posiciones que son visibles en la pantalla para la visualización de artículos. Por ejemplo, un ListView tiene ranuras horizontales, uno por cada artículo y un GridView tiene una rejilla 2D de las franjas horarias.

Cada contenedor acepta un objeto View y lo muestra en una ranura.

Por ejemplo, usted podría proporcionar el ListView con objetos TextView y sería simplemente mostrar texto en cada una de sus ranuras.

Tal vez se pregunte por qué no acaba de suministrar un conjunto de cadenas para el ListView y dejarlo trabajar la manera de mostrar las cadenas como texto?

Las cosas podrían ser organizados de esta manera y sería más simple - pero sólo si se querían mostrar Cuerdas. Si desea mostrar una lista de imágenes, por ejemplo, entonces usted tendría un ListView que entiende las imágenes y así sucesivamente.

Es mucho más flexible para proporcionar el contenedor con un conjunto de predispuestas Ver objetos porque entonces el contenedor simplemente tiene que mostrar el objeto Ver sin tener que realizar ninguna conversión.

Todos los contenedores que se derivan de la utilización maquillaje clase AdapterView de adaptadores para suministrar lo que se muestran en términos de objetos View. Estos incluyen, así como el ListView y GridView, el hilandero, Galería y StackView.

Ya hemos visto en el uso de la Spinner y su adaptador asociado en un capítulo anterior así que esta vez es el turno de un elemento más avanzada interfaz de usuario - la ListView y su adaptador.

Este enfoque también tiene la ventaja de que se puede brindar el contenedor con un objeto View que es un diseño completo es decir, que podría ser en sí mismo un contenedor con una gran cantidad de objetos de vista para mostrar. Por ejemplo, usted podría suministrar un ListView con un objeto View que contiene una imagen y un TextView para crear una lista de multimedia de imágenes y texto.

Por supuesto, si el envase no está haciendo la conversión del objeto de datos al objeto View - usted va a tener que hacerlo.

Aquí es donde el adaptador entra.

El ListView y los contenedores de GridView ambos hacen uso de la clase ListAdapter como su adaptador de base.

En general usted tiene que tomar la clase ListAdapter y extenderlo a crear su propio adaptador costumbre que genera un objeto View personalizado para el recipiente a utilizar en cada una de sus ranuras. El contenedor pide el objeto View que se utiliza para mostrar el punto i o utilizando cualquier indexación adapte el contenedor particular. El adaptador devuelve el objeto View y el contenedor de la muestra - sin preocuparse de lo que es o lo que corresponde.

Esto puede sonar complicado, pero resulta ser muy simple en la práctica.

Sin embargo, para hacer las cosas aún sencillo también hay un ArrayAdapter que le permite desplegar un solo elemento de texto para cada elemento de una matriz de objetos arbitrarios.

¿Cómo es esto posible funciona si el objeto de la matriz puede ser cualquier cosa?

Lo primero a señalar es que ArrayAdapter es una clase genérica y puede aceptar un arreglo de cualquier tipo, siempre y cuando así lo especifican al crear la instancia ArrayAdapter.

La segunda cosa a destacar es que el adaptador de matriz llama cada artículos método toString para conseguir un poco de texto para que aparezca en el envase - muy sencillo pero también muy restrictiva. De hecho, es bastante fácil de modificar lo que los ArrayAdapter pantallas y esto hace que sea más versátil que se puede esperar y por lo tanto vale la pena conocer.

Entonces, para resumir:

Contenedores como ListView y visualización GridView Ver objeto en una disposición particular - como una lista vertical o como una rejilla 2D en este caso.

Un adaptador convierte los datos que se va a mostrar en cada ranura en una vista de objeto adecuado.

Para los datos y visualizaciones complejas que necesita para crear un adaptador personalizado.

En muchos casos, sin embargo, el ArrayAdapter se puede utilizar.

El ArrayAdapter, en su forma más básica, puede suministrar objetos TextView a un contenedor de una matriz de cualquier tipo simplemente llamando métodos toString del objeto.

El ArrayAdapter

En lugar de comenzar con un ejemplo que es completamente general es digno de mirar cómo se utiliza la ArrayAdapter en conjunción con un ListView.

Inicie un nuevo proyecto llamado Android Estudio ListViewExample basado en una actividad en blanco y aceptar todos los valores predeterminados.

Para un ejemplo simple todo lo que vamos a hacer es mostrar una lista de nombres en un ListView.

En primer lugar eliminar la habitual "Hello World" textView.In el diseñador desplazarse por la paleta hasta que pueda ver la Contenedores y colocar un ListView en la superficie de diseño.

Usted verá que por el bien de lo que le permite trabajar con el diseño del diseñador mostrará la ListView lleno de unos dos objetos de texto artículo. Nuestro adaptador va a ser más sencillo que esta pantalla maniquí con una sola línea de texto.

Si ejecuta el programa en esta primera etapa usted no ve nada en el ListView - que estará en blanco. El texto que se ve en el diseñador es sólo para ayudarle a visualizar la interfaz de usuario - no hay adaptador asociado con el ListView y por lo tanto cuando lo ejecuta no hay nada para mostrar.

Nuestra próxima tarea es crear un objeto ArrayAdapter para abastecer el ListView con algo para mostrar.

Pero primero necesitamos una matriz de cadenas para contener el texto que vamos a mostrar. Para simplificar, podríamos añadir el código al método onCreate en MyActivity.java. Para crear un simple array Alfa podemos utilizar un literal:

String[] myStringArray={"A","B","C"};

no dude en pensar en algo más creativo que A, B, C. En el mundo real las cuerdas probablemente se lee de un archivo o una base de datos, etc.

Lo siguiente que necesitamos para crear el ArrayAdapter. Para ello el constructor necesita el contexto, por lo general esto, una disposición a utilizar para mostrar cada cadena y el conjunto de la secuencia:

ArrayAdapter<String> myAdapter=new ArrayAdapter<String>( this, android.R.layout.simple_list_item_1, myStringArray);

Note la manera que el tipo de la matriz se especifica como <String>. Si usted no está familiarizado con los genéricos de Java, entonces usted necesita para buscar cómo funciona todo. También note el uso del estándar suministrado simple_list_item1 diseño. Usted puede crear sus propios diseños y veremos cómo se hace esto en un momento.

Por último tenemos que asociar el adaptador con el ListView:

ListView myList= (ListView) findViewById(R.id.listView); myList.setAdapter(myAdapter);

El método onCreate completa es:

protected void onCreate( Bundle savedInstanceState){ super.onCreate(savedInstanceState); setContentView(R.layout.activity_my); String[] myStringArray={"A","B","C"}; ArrayAdapter<String> myAdapter=new ArrayAdapter<String>( this, android.R.layout.simple_list_item_1, myStringArray); ListView myList=(ListView) findViewById(R.id.listView); myList.setAdapter(myAdapter); }

Si ahora ejecuta el programa, verá una lista ordenada con cada elemento de la matriz que se muestra en una línea - como se había prometido.

Hasta ahora esto no se ve impresionante, pero el ListView le da algunos servicios básicos. Por ejemplo, si se aumenta el número de elementos de la matriz:

String[] myStringArray= {"A","B","C","D","E","F","G","H","I","J","K"};

Usted descubrirá que puede desplazarse automáticamente a través de la lista con el gesto habitual película.

Trabajando con los datos

El punto de mostrar al usuario una lista de elementos es de manera que puedan interactuar con él. Puede manipular los datos en la pantalla de diversas maneras y manejar los eventos cuando el usuario selecciona un elemento.

Obtener SelecciónTal vez lo más importante es hacer frente a la selección del usuario y el tema. La forma habitual de hacer esto es escribir un controlador para el OnItemClickListener. Esto pasa cuatro parámetros

onItemClick(AdapterView parent, View view, int position, long id)

El AdapterView es la visión completa que muestra el envase, la vista es la vista de objetos del usuario seleccionado, la posición en la recogida y el id es el número de elementos de identificación en el contenedor. Para una ArrayAdapter el ID es el mismo que el índice de matriz.

Puede utilizar este evento para averiguar lo que el usuario ha seleccionado y modificarlo. Por ejemplo, el controlador de eventos:

AdapterView.OnItemClickListener mMessageClickedHandler = new AdapterView.OnItemClickListener() { public void onItemClick(AdapterView parent, View v, int position, long id) { ((TextView)v).setText("selected"); 

} };

establece cada elemento el usuario selecciona "seleccionado" - no es útil, pero usted puede cambiar el color a gris a cabo la selección.

Es importante saber que el cambio de lo que la vista de objetos muestra no cambia los datos almacenados en la estructura de datos asociada. Es en este contexto una fila para "seleccionado" no cambia la entrada del conjunto de cuerdas caso.

Para configurar el controlador a la ListView se debería utilizar:

myList.setOnItemClickListener( mMessageClickedHandler);

También puede establecer la selección en código usando:

myList.setSelection(position);

donde la posición es la posición de base cero del elemento de la lista y puede desplazarse para mostrar cualquier elemento utilizando

myList.smoothScrollToPosition(position);

Un punto sutil vale la pena mencionar es que no se puede hacer uso del objeto de vista que se pasa al controlador de eventos para mostrar la selección en otra parte de la disposición. Un objeto de vista sólo puede estar en la jerarquía de disposición de una vez.

En la mayoría de los casos esto no es un problema porque normalmente se puede clonar manualmente el objeto View. Por ejemplo, en este caso el objeto View es un TextView y así que usted puede crear un nuevo TextView y establecer su propiedad Text a ser el mismo que el de la una en la lista. Por ejemplo:

TextView w=new TextView(getApplicationContext()); w.setText( ((TextView)v).getText()); LinearLayout myLayout= (LinearLayout) findViewById(R.id.layout); myLayout.addView(w);

Esto puede ser más una molestia si el objeto View es más compleja.

Modificación de los datosUna de las cosas un poco confusos sobre el uso de adaptadores es la relación entre lo que se muestra y lo que está en la estructura de datos subyacente. Puede cambiar los datos, pero si quieres ver el cambio en el contenedor que tenga que utilizar un adaptador notificar método para decirle que los datos han cambiado.

Por ejemplo, si cambia un elemento de la matriz:

myStringArray[0]="newdata";

entonces nada va a mostrar hasta que utilice:

ListView myList= (ListView) findViewById(R.id.listView); ArrayAdapter myAdapt= (ArrayAdapter)myList.getAdapter(); myAdapt.notifyDataSetChanged();

Tenga en cuenta que usted tiene que emitir el ListAdapter regresó de getAdapter a un ArrayAdapter para llamar al método de notificación.

Hay una segunda forma de cambiar los datos utilizando la propia ArrayAdapter. Esto proporciona una serie de métodos para agregar, insertar, limpiar, remover e incluso ordenar los datos en el adaptador. El gran problema es que si se utiliza cualquiera de estos entonces la estructura de datos subyacente asociada con el adaptador tiene que apoyarlos.

Por ejemplo, el método add añade un objeto en el extremo de la estructura de datos pero si intenta:

myAdapt.add("new data");

con el programa configurado actualmente usted encontrará que usted consigue un accidente de tiempo de ejecución. La razón es que en Java una matriz tiene un tamaño fijo y el método add intenta añadir el artículo a la final de la matriz que no es posible.

Si desea agregar elementos al final de una matriz como la estructura de datos es necesario utilizar un ArrayList y no sólo una simple matriz. Un ArrayList puede aumentar o disminuir su tamaño.

Por ejemplo, podemos crear un ArrayList de fuera Array cadena existente:

ArrayList<String> myArrayList= new ArrayList<String>();

y se puede asociar este nuevo ArrayList con el adaptador en lugar de la matriz de la secuencia:

ArrayAdapter<String> myAdapter= new ArrayAdapter<String>( this, android.R.layout.simple_list_item_1, myArrayList);

A raíz de ello se puede utilizar:

myAdapt.add("new data");

y verá los nuevos datos al final de la lista mostrada. Puede que tenga que desplazarse para verlo.

Mientras usted está utilizando un ArrayList que son seguros de usar todos los datos del adaptador métodos de modificación:

add(item) addAll(item1,item2,item3...) clear() //remove all data insert(item,position) remove(item)

También puede hacer uso de

getCount() //get number of elements getItem(position) // get item getItemId(position) //get item id

y

getPosition(item)

Un diseño personalizado

Uso Hasta ahora acabamos de hacer del sistema proporciona el diseño de la fila. Es muy fácil crear su propio archivo de diseño y configurarlo para que se utiliza para representar cada fila - pero hay que tener en cuenta que los únicos datos que se mostrará que es diferente en cada fila se deriva de los artículos. método toString.

El diseño personalizado simple tiene que tener un solo control TextView que se utiliza para cada línea. De hecho esto es tan simple que no tiene ventajas sobre el sistema suministrado diseño así que esto es realmente sólo para mostrar cómo funcionan las cosas.

Utilice Android Studio para crear un nuevo diseño en el directorio de diseño estándar y lo llaman mylayout.xml. Utilice el editor de diseñador o de texto para crear un diseño con un solo objeto TextView:

<?xml version="1.0" encoding="utf-8"?> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:textAppearance="? android:attr/textAppearanceLarge" android:text="Large Text" xmlns:android= "http://schemas.android.com/apk/res/android" android:id="@+id/textView"> </TextView>

Si elimina el contenedor predeterminado puede ver mensajes de error. Simplemente ignorarlos y seguir adelante con poner una TextView en el diseño.

Para utilizar el diseño que simplemente proporcione su ID de recurso en el constructor ArrayAdapter:

ArrayAdapter<String> myAdapter= new ArrayAdapter<String>( this, R.layout.mylayout, myStringArray);

Si intenta esto usted no ve ninguna gran diferencia entre esto y cuando se utiliza la disposición del sistema android.R.layout.simple_list_item_1.

El siguiente nivel es el uso de un diseño que tiene más que un solo TextView en ella. La única complicación en este caso es que usted tiene para ofrecer no sólo la identificación de la distribución pero el id de la TextView en el diseño que desea utilizar para los datos.

Por ejemplo, si crea una presentación con un LinearLayout horizontal y colocar un CheckBox, y dos TextViews:

A continuación, puede utilizar el diseño mediante la creación de la ArrayAdapter con:

ArrayAdapter<String> myAdapter= new ArrayAdapter<String>( this, R.layout.mylayout, R.id.textView2, myStringArray);

suponiendo que el TextView desea que los datos aparezcan en es textView2.

El resultado es un poco más impresionante que el ejemplo anterior:

Note que cada uno de los objetos de vista en la disposición da lugar a una instancia distinta por línea. Esa es su diseño sólo puede haber tenido un CheckBox pero el ListView tiene una línea por. Esto significa que cuando el usuario selecciona la línea que usted puede recuperar la configuración de la casilla de verificación decir. También significa que un ListView puede generar montones y montones de objetos de vista muy rápidamente y esto puede ser una carga para el sistema.

Nota importante:Hay algunas cosas que usted necesita saber si usted va a manejar con éxito eventos onItemClick.

La primera es que su diseño no puede tener Vistas enfocables o puede hacer clic. Si lo hace, entonces el aún no se eleva y el controlador no se llama.

La solución es para detener cualquier objeto View en el recipiente de ser enfocable. Añadir

android:descendantFocusability="blocksDescendants"

al LinearLayout decir o utilizar la ventana de propiedades para establecerlo en blocksDescendants - ya que es una propiedad avanzada tiene que seleccionar "Mostrar avanzado".

Con este cambio, el controlador de eventos debe ser llamado, pero ahora tienes que tener en cuenta que el objeto View pasa como v en:

public void onItemClick(AdapterView parent, View v, int position, long id)

es el objeto de vista completa de la fila y no sólo el TextView.Es decir en el caso del ejemplo anterior sería el LinearLayout además de todos sus hijos.

Si usted va a trabajar con el objeto View que tiene que acceder a los objetos contenidos en él y usted puede hacer esto es de la forma habitual. Por ejemplo:

AdapterView.OnItemClickListener mMessageClickedHandler = new AdapterView.OnItemClickListener(){ public void onItemClick(AdapterView parent, View v, int position, long id) { TextView myData = (TextView) v.findViewById(R.id.textView2); myData.setText("Selected"); } };

Observe que puede utilizar findViewById en la vista que se devuelve.

Un ArrayAdapter personalizada

Mientras usted puede hacer frente a lo que se muestra para cada fila de ser una cadena devuelta por el método toString del objeto, puede utilizar un ArrayAdapter estándar. Incluso puedes personalizar método toString del objeto para mostrar algo diferente - pero aún así es una cadena.

Si usted tiene una gran variedad de objetos generales y desea mostrar varios artículos de cada objeto o artículos que no son cadenas, entonces usted necesita para crear un

ArrayAdapter personalizado. Esto no es difícil pero hay uno o dos puntos más avanzados para tomar nota de que para este primer ejemplo - vamos a mantener lo más simple posible.

Primero necesitamos algunos objetos para contener los datos que vamos a mostrar - un tipo de registro decir con un campo para el nombre y otro para el número en stock decir, también se puede añadir una foto del artículo, sino en el espíritu de hacer que sea sencillo una Cuerdas y e int son suficientes.

Si conoces a otros idiomas que podrían estar pensando que necesitamos un stuct o algo similar. En Java no hay estructuras. Si desea crear un registro se crea un objeto con las propiedades necesarias.

Inicie un nuevo proyecto llamado CustomList y aceptar todos los valores predeterminados. Navegue hasta el directorio principal de Java, haga clic derecho y seleccione Nuevo, Clase. Llame a la MyData clase y escriba:

public class MyData { public String myTitle; public int myNum;

public MyData(){ super(); } 

public MyData(String myTitle, int myNum) { super(); this.myTitle = myTitle; this.myNum = myNum; } }

La nueva clase tiene dos campos públicos MyTitle y myNum y un constructor de encargo que nos permite inicializar estos campos. La adición de este constructor de inicialización hace que sea fácil crear arrays de la nueva clase.

Por ejemplo, en el método onCreate puede agregar

MyData myDataArray[]=new MyData[]{ new MyData("item1",10), new MyData("item2",20), new MyData("item3",30) };

Puede que tenga que agregar más datos de este para probar el ListView correctamente.

Ahora tenemos algunos datos para mostrar que necesitamos agregar el adaptador personalizado.

Una vez más, haga clic derecho en el directorio java y crear una nueva clase llamada MyAdapter. Esto tiene que heredar de ArrayAdapter:

public class MyAdapter extends ArrayAdapter<MyData> { }

Nótese que queremos que el ArrayAdapter genérico para trabajar con objetos MyData. La mayoría de los métodos de ArrayAdapter funcionará perfectamente bien con matrices de objetos arbitrarios.

A continuación tenemos que añadir un constructor adecuado en base a los constructores que ArrayAdapter tiene. Android Studio puede ayudar.

Haga clic en la línea de clase y seleccione Generar, Constructor. Verá una lista de posibles constructores. La que nosotros queremos utilizar es el tercero en la lista.

Al seleccionarlo se genera el siguiente código para usted:

public MyAdapter(Context context, int resource, MyData[] objects) { super(context, resource, objects); }

Tenemos que ampliar esto porque tenemos que seguir la pista de contexto, los recursos y la matriz de objetos y primero necesitamos algunas variables para almacenarlos en:

private Context context; private int resource; private MyData[] objects;

El constructor puede ahora almacenar los valores pasados a estas variables:

public MyAdapter(Context context, int resource, 

MyData[] objects) { super(context, resource, objects); this.context=context; this.resource=resource; this.objects=objects; }

Nótese que con este constructor nuestro adaptador se utiliza en la misma forma que en el ejemplo anterior - suministramos contexto, ID de recurso y el conjunto de datos.

Ahora llegamos a la parte clave de la personalización - anulando método getView del adaptador. Este es el núcleo de la funcionalidad del adaptador. Cada vez que el ListView necesita mostrar una nueva fila se llama al método getView del adaptador y espera volver un objeto View que puede mostrar como la fila.

Para anular el método que puede utilizar Android Studio para generar algo de código. Haga clic derecho en la clase de adaptador y seleccione Generar, método de anulación y seleccione getView. El código generado no es particularmente útil, pero al menos se pone la firma del método correcto:

@Override public View getView(int position, View convertView, ViewGroup parent) { return super.getView(position, convertView, parent); }  

Realmente no importa cómo getView genera el objeto View que va a regresar, pero la forma más común de hacer el trabajo es inflar un archivo de diseño.

Para dar el inflador algo para trabajar con el botón derecho sobre la carpeta res / layout y seleccione Nuevo archivo de diseño. Llame a la mylayout archivo y cambiar el LinearLayout a horizonal y añadir dos TextViews con el título y el número de identificadores. Siéntase libre de cambiar el diseño para hacer que las cosas se ven bastante - no lo puedo cambiar el código que necesita para escribir.

Nuestra primera tarea es conseguir un inflador e inflar el archivo de diseño:

LayoutInflater inflater= ((Activity) context).getLayoutInflater(); View row=inflater.inflate(resource,parent,false);

Nótese que hacemos uso de la Identificación de recursos almacenamos cuando el constructor corrió y usamos el objeto padre Ver aprobada en el método getView. El único propósito el padre objeto View sirve es para permitir que el sistema de la disposición de los recursos en un recipiente conocido. El parámetro falsa último le dice al inflado de no añadir el objeto generado recursos para los padres - este es un trabajo para el ListView.

Antes de ello tenemos que poner los datos en el objeto View.Para ello tenemos que encontrar los dos objetos TextView que nos coloca en el diseño y esto es sólo una cuestión de cantar el patrón findViewById familiar:

TextView title= (TextView) row.findViewById(R.id.title); TextView number=(TextView) row.findViewById(R.id.number);

Una vez que tenga los objetos de vista que tenga que cambiar puede utilizar el parámetro de posición para obtener los datos de la matriz de objetos que se establecen por el constructor:

title.setText((CharSequence) objects[position].myTitle); number.setText(Integer.toString( objects[position].myNum));

Eso es todo, hace trabajo. Todo lo que necesitamos hacer ahora es devolver el objeto fila Vista:

return row; }

La clase myAdapter completa es:

public class MyAdapter extends ArrayAdapter<MyData> { private Context context; private int resource; private MyData[] objects; 

public MyAdapter(Context context, int resource, MyData[] objects) { super(context, resource, objects); this.context=context; this.resource=resource; this.objects=objects; } 

@Override public View getView(int position, View convertView, ViewGroup parent) { LayoutInflater inflater= Activity) context).getLayoutInflater(); View row=inflater.inflate(resource,parent,false);TextView title= (TextView) row.findViewById(R.id.title); TextView number=(TextView) row.findViewById(R.id.number); title.setText((CharSequence) objects[position].myTitle); number.setText(Integer.toString( objects[position].myNum)); return row; 

} }

Ahora todo lo que tenemos que hacer es escribir algo de código que hace uso de la nueva clase y esto es exactamente el mismo que el código que hizo uso de la ListView Stanard:

MyAdapter myAdapter=new MyAdapter( this, R.layout.mylayout, myDataArray); ListView myList = (ListView) findViewById(R.id.listView); myList.setAdapter(myAdapter);

Y, por supuesto, no te olvides de poner un componente ListView en el diseño principal.

Si ejecuta el programa que ahora verá una lista que consta de dos TextViews cada uno con algo diferente para mostrar en cada línea. En una aplicación real que probablemente no crea una nueva clase para dos elementos de texto - reemplazando el método toString sería más fácil, pero los principios son los mismos sin importar las Ver múltiples objetos creados por el adaptador son.

La reutilización, almacenamiento en caché y las presentaciones generales

Tenemos una clase adaptador personalizado de trabajo pero hay algunas cosas que podemos hacer para que sea mejor.

La primera se refiere a la eficiencia.

Si usted recuerda, se señaló que una gran lista de objetos podría dar lugar a la creación de una gran cantidad de objetos de vista. En la práctica, sin embargo, realmente sólo necesitamos el número de objeto View que corresponden a filas en realidad se muestran en la pantalla.

Para evitar tener que disponer de ellos ya crear nuevos Objetos de visión todo el tiempo el ListView te da la oportunidad de reciclar los objetos de vista que ya haya creado. Esto es lo que el parámetro convertView en el método getView se trata. Si es nulo tiene que inflar y crear un nuevo objeto View. Si no es nulo, entonces es un objeto View listo para ser utilizado y usted no tiene que crear una nueva.

Modificación del ejemplo anterior para hacer uso de convertView es fácil:

View row; if(convertView==null) { LayoutInflater inflater = ((Activity) context).getLayoutInflater(); row = inflater.inflate(resource, parent, false); }else{ row=convertView; }

Se trata de un aumento de velocidad pena hacer y evita así tener que crear un montón de objetos de vista y disponer de ellos.

Sin embargo todavía estamos buscando a la niña Objetos de visión cada vez que queremos cambiar los datos. Esto es:

TextView title= (TextView) row.findViewById(R.id.title); TextView number=(TextView) row.findViewById(R.id.number);

Esto también es muy derrochador y se puede evitar con la aplicación del patrón ViewHolder.

Todo lo que tenemos que hacer es guardar las referencias a los niños en un objeto y almacena esta en la matriz de Ver propiedad etiqueta. Entonces la próxima vez que vemos al padre Ver que no tiene que encontrar a los niños que estamos buscando - que se almacenan en la etiqueta de los padres como un objeto ViewHolder.

En primer lugar tenemos que crear un objeto ViewHolder:

private static class ViewHolder { TextView title; TextView number; }

Tenga en cuenta que esto no tiene campos que puedan contener referencias a nuestros dos objetos TextView.

La lógica del método getView es ahora también para crear y almacenar un objeto ViewHolder si no estamos reciclando un objeto View

View row; ViewHolder viewHolder; if (convertView == null) { viewHolder = new ViewHolder(); LayoutInflater inflater = ((Activity) context).getLayoutInflater(); row = inflater.inflate( resource, parent, false); viewHolder.title = (TextView) row.findViewById(R.id.title); viewHolder.number = (TextView) row.findViewById(R.id.number); row.setTag(viewHolder); }

Tenga en cuenta que hemos almacenado las referencias a los TextViews en el viewHolder y almacenada en este campo Etiqueta de la fila - esto es lo campos de la etiqueta genreally se utilizan.

Si nosotros tenemos un objeto View reciclado entonces sólo tenemos que obtener el objeto viewHolder:

} else { row = convertView; 

viewHolder = (ViewHolder) convertView.getTag(); }

Por último, no importa donde el objeto viewHolder vino de que sólo lo utilizan:

viewHolder.title.setText( (CharSequence) objects[position].myTitle); viewHolder.number.setText( Integer.toString(objects[position].myNum)); return row; }

Con este cambio se ha evitado la creación de un objeto de vista cada vez y hemos evitado tener que buscar el niño objetos cada vez - un ahorro muy útiles en tiempo y recursos.

Finalmente hay un último pulimento de aplicar. Por el momento el diseño de la fila tiene que tener los identificadores de los objetos TextView establecidas al título y número. Mucho mejor para permitir al usuario establecer estos en el constructor:

public MyAdapter(Context context, int resource, int resTitle, int resNumber, MyData[] objects) { super(context, resource, objects); this.context = context; this.resource = resource; this.textRes1= resTitle; this.resNumber = resNumber; this.objects = objects; }

Este constructor tiene dos parámetros adicionales que se utilizan para especificar los números de identificación de los dos objetos ViewText en el diseño. Estos se almacenan en las variables privadas para su uso posterior - y tenemos que declarar las variables privadas:

private int resTitle; private int resNumber; 

El constructor original todavía se puede mantener el tiempo que establece resTitle y resNumber:

public MyAdapter(Context context, int resource, MyData[] objects) { super(context, resource, objects); this.context = context; this.resource = resource; this.objects = objects; this.resTitle =R.id.title; this.resNumber =R.id.number; }

Por último tenemos que cambiar el método getView utilizar las dos nuevas variables privadas:

viewHolder.title = (TextView) row.findViewById(resTitle); viewHolder.number = (TextView) row.findViewById(resNumber);

Con estos cambios, el adaptador se puede utilizar como:

MyAdapter myAdapter=new MyAdapter( this, R.layout.mylayout, R.id.title, R.id.number, myDataArray);

y el usuario es libre de utilizar ningún código para el diseño, siempre hay dos TextViews.

Resumen

Contenedores como ListView trabajan juntos con un adaptador para mostrar los datos. 

El adaptador acepta una estructura de datos - por lo general una matriz o una lista - y convierte cualquier elemento de datos en un objeto View que representa los datos. 

Puede manejar un evento de selección para averiguar lo que el usuario ha seleccionado. 

La vista de objetos puede ser complejo con un recipiente exterior y cualquier número de objetos secundarios. 

El ArrayAdapter básica utiliza el método toString de cada objeto de proporcionar los datos para mostrar en un objeto ViewText. 

Si desea mostrar algo que no sea el resultado de llamar toString es necesario implementar un ArrayAdapter personalizado. 

Para hacer esto usted tiene que reemplazar el método getView heredado. 

El ListView es lo suficientemente inteligente como para ofrecerle Ver objetos para reciclar - aunque usted no tiene que hacerlo si no quieres. 

El patrón ViewHolder puede hacer que su uso de anidado Objetos de visión más eficiente.

Qué Está Faltando?

Al igual que con todas las cosas, hay aspectos de la ListView que no se han cubierto. En particular, ¿qué hacer si su estructura de datos no es una matriz? El ArrayAdapter puede manejar listas, simplemente anular el constructor adecuado.Cualquier cosa más compleja y

que tendrá que crear un adaptador personalizado. En la mayoría de casos, sin embargo, esto no es necesario porque la mayoría de las estructuras de datos pueden ser mapeadas a una matriz.

Hay una serie de temas de formato no cubierta - la cabecera y el separador, por ejemplo - pero éstas son relativamente fáciles.

Más complicado son las opciones de selección múltiple y cualquier lista personalizada muestra como una lista con varias columnas o pop-out detalle ventanas.

Todos son posibles temas para futuros capítulos.

Adaptador personalizada

public class MyAdapter extends ArrayAdapter<MyData> { private Context context; private int resource; private MyData[] objects; private int resTitle; private int resNumber; 

public MyAdapter(Context context, int resource, MyData[] objects) { super(context, resource, objects); this.context = context; this.resource = resource; this.objects = objects; this.resTitle =R.id.title; this.resNumber =R.id.number; } 

public MyAdapter(Context context, int resource, int resTitle, int resNumber, MyData[] objects) { super(context, resource, objects); this.context = context; this.resource = resource; this.resTitle = resTitle; this.resNumber = resNumber; this.objects = objects; } 

private static class ViewHolder { TextView title; TextView number; 

} 

@Override public View getView(int position, View convertView, ViewGroup parent) { View row; ViewHolder viewHolder; if (convertView == null) { viewHolder = new ViewHolder(); LayoutInflater inflater = ((Activity) context).getLayoutInflater(); row = inflater.inflate(resource, parent, false); viewHolder.title = (TextView) row.findViewById(resTitle); viewHolder.number = (TextView) row.findViewById(resNumber); row.setTag(viewHolder); } else { row = convertView; viewHolder = (ViewHolder) convertView.getTag(); } viewHolder.title.setText((CharSequence) objects[position].myTitle); viewHolder.number.setText(Integer.toString( objects[position].myNum)); return row; } }

Puede descargar el código de los programas de la CodeBin(nota hay que registrarse primero).