Investigacion de Android

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

RadioButon Los RadioButtons que al igual que los checkbox, hereda de la clase CompoundButton y TextView.

Cuando vamos a trabajar con radiobuttons desde los archivos de layout en XML, generalmente tendremos primero que hacer uso del elemento RadioGroup, que indica que los RadioButton contenidos en él se encuentran vinculados, permitiendo que el usuario únicamente pueda seleccionar una opción a la vez. Para que podamos manipular el RadioGroup desde el código Java de la aplicación deberemos asignarle un atributo android:id con el valor que queramos. De esta manera podemos hacer uso de los siguientes métodos:   



check() para que un radiobutton del grupo aparezca seleccionado. Para especificar cuál de los radio buttons se seleccionará debemos hacer uso del formato R.id.[idDelRadioButton]. clearCheck() para limpiar el grupo de radio buttons para que ninguna aparezca seleccionado. getCheckedRadioButtonId() para obtener el ID del radio button que actualmente está seleccionado por el usuario, en caso de que ninguno esté seleccionado, este método nos retornará el valor de -1.

Los demás métodos que puedes utilizar cuando trabajas con la clase RadioGroup los puedes consultar en la tabla XML Attributes que puedes encontrar en la documentación oficial de Android Developers.

Código…

1. Pasemos a la parte práctica creando un proyecto llamado AndroideityRadioButton con la versión Android 2.1 update 1.

2. Vamos a construir nuestro grupo de radio buttons modificando el archivo main.xml del directorio res/layout como te muestro a continuación:

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

 

Declaramos un elemento <RadioGroup> como raíz del documento para que contenga 4 <RadioButton> relacionados y así podamos seleccionar uno a la vez.

Le asignamos el atributo android:id a cada <RadioButton> esto es útil cuando quieras manipular los elementos en el código de tu aplicación.

3. Ejecutamos el proyecto. Como puedes ver el layout que se muestra en pantalla nos permite elegir un elemento a la vez lo que quiere decir que el grupo de radio buttons está relacionado.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

De forma predeterminada, ningún radio button aparece seleccionado, cuestión que podría cambiar si utilizamos desde el código Java el método setCheck() o check() sobre el RadioGroup que definimos en el XML. En tutoriales más complejos estaremos haciendo un uso más avanzado de este y los demás elementos de la GUI de Android. Por el momento es bueno que conozcas de forma básica los conceptos más importantes y esenciales de su utilización. varios atributos bastante útiles que estos elementos heredan directamente de la clase View.

Así también, voy a resaltar una serie de propiedades y métodos que considero importantes y útiles para que los tomes en cuenta.

Algunas propiedades de la clase View que te recomiendo utilizar: 

Para controlar la secuencia en la que se cambia el foco de un elemento a otro: o android:nextFocusDown o android:nextFocusLeft o android:nextFocusRight o android:nextFocusUp

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”  

android:visibility para indicar si el elemento estará visible cuando se carga el layout en la aplicación. android:bakcground que permite definir el valor de un color bajo el formato RGB para que juguemos con el aspecto visual de los elementos de la GUI.

Entre los métodos encontramos: 





setEnable() e isEnabled() que nos ayudarán a hacer que un elemento de la GUI esté disponible para que el usuario pueda interactuar con él y el segundo, para que sepamos el estado de disponibilidad de los elementos. requestFocus() e isFocused() que nos ayudará a conocer cuando el usuario ha puesto el foco sobre algún elemento en específico, esto puede servirnos para desencadenar validaciones en la información que se introduzca en un campo de texto una vez que el usuario pase a proporcionar los siguientes datos del formulario por poner un ejemplo.

Para auxiliarnos en la navegación entre los widgets y sus contenedores, podemos hacer uso de: o getParent() para conocer el elemento padre o contenedor de un widget en específico dentro del layout. o getParentOfType() para localizar los elementos padres inmediatos de un widget, por ejemplo RadioGroup sería el elemento padre inmediato de un RadioButton. o findViewById() este método es de los que utilizarás con más frecuencia y nos ayudará a hacer referencia de una elemento que esté declarado en el layout en XML desde el código Java para que podamos utilizarlo en la aplicación y asignarle eventos, características, etc. o getRootView() para obtener el elemento raíz de los elementos del XML.

Fuente de extracción: http://androideity.com/2011/07/13/widgets-basicos-en-android-vradiobutton/

ListItem Haga clic en Archivo -> Nuevo -> Proyecto y seleccione el asistente "Android Project":

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Haga clic en Siguiente y complete la siguiente pantalla con los siguientes valores:

Una vez que haya completado todos los datos necesarios se puede hacer clic en Finalizar.

Su nuevo proyecto se acaba de crear. Ahora vamos a modificarlo un poco para mostrar nuestra lista de encargo.

Abre SoftwarePassionView.java en el editor de eclipse y cambiar el archivo de clase a lo siguiente: 1. Definir las variables necesarias miembros vamos a utilizar más adelante en nuestra clase

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 1privada ProgressDialog m_ProgressDialog = null; 2privada ArrayList <Order> m_orders = null; 3privada OrderAdapter m_adapter; 4privadas viewOrders ejecutables;

m_ProgressDialog es un pequeño pop up que muestra la información de que sus datos se descarga o se recupera otra manera. m_orders es un ArrayList que contendrá los datos descargados de Internet o adquirido otra manera m_adapte r es nuestra clase personalizada que se extiende ArrayAdapter viewOrders es un ejecutable para descargar datos de Internet en un hilo separado Para importar todo lo que pueda en este momento haga clic en Ctrl + Shift + O, algunas clases como Orden o OrderAdapter no se crean, pero aún no se preocupe, vamos a llegar a ese punto en breve.

Otra nota importante en este momento es que su SoftwarePassoinView debe extenderse ListActivity lugar de simple actividad.

La clase debe tener un aspecto más o menos como esto ahora: 1 paquete de com.softberries.lve; 2 3 java.util.ArrayList importación; 4 importar android.app.ListActivity; 5 android.app.ProgressDialog importación; 6 android.os.Bundle importación; 7 8 pública SoftwarePassionView clase extiende ListActivity { 9 10privada ProgressDialog m_ProgressDialog = null; 11privada ArrayList <Order> m_orders = null; 12privada OrderAdapter m_adapter; 13privadas viewOrders ejecutables; 14 15/ ** Se le llama cuando la actividad se creó por primera vez. * / 16@ Override 17onCreate public void (paquete savedInstanceState) { 18. súper onCreate (savedInstanceState); 19setContentView (R. diseño principal.);

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 20} 21}

Ahora vamos a crear nuestra clase de la Orden sencilla la celebración de pedido.

Haga clic derecho sobre el proyecto y y seleccione 'Nuevo' -> 'Clase', nombre que ordenar y abrirlo en el editor.

El código fuente de los pedidos es el siguiente: 1 paquete de com.softberries.lve; 2 3 Orden {public class 4 5 orderName cadena privada; 6 private String OrderStatus; 7 8 getOrderName public String () { 9 volver orderName; 10} 11public void setOrderName (String orderName) { 12este orderName = orderName.; 13} 14pública getOrderStatus String () { 15volver OrderStatus; 16} 17public void setOrderStatus (String OrderStatus) { 18este OrderStatus = OrderStatus.; 19} 20}

La clase de la Orden es muy simple y contiene solamente dos cuerdas con getters y setter generados por ellos Ahora vamos a cambiar nuestro archivo main.xml para mantener nuestros elementos de lista personalizados: 1 <? Xml version = "1.0" encoding = "UTF-8"?> 2 <LinearLayout xmlns: android = "http://schemas.android.com/apk/res/android" 3 android: orientation = "vertical"

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 4 android: layout_width = "fill_parent" 5 android: layout_height = "fill_parent" 6 > 7 <ListView 8 android: id = "+ @ id / android: list" 9 android: layout_width = "fill_parent" 10android: layout_height = "fill_parent" 11/> 12<TextView 13android: id = "+ @ id / android: empty" 14android: layout_width = "fill_parent" 15android: layout_height = "fill_parent" 16android: text = "@ string / main_no_items" /> 17</ LinearLayout>

Esta disposición se mostrará a nuestros elementos de la lista en su caso y si la lista está vacía, se mostrará "No hay pedidos para mostrar 'cadena se define en el archivo de recursos string.xml.

1<? Xml version = "1.0" encoding = "UTF-8"?> 2<Recursos> 3<Nombre de la cadena = "hola"> Hola a todos, SoftwarePassionView </ string> 4<Nombre de la cadena = "app_name"> Pasión de software </ string> 5<Nombre de la cadena = "main_no_items"> No hay pedidos para mostrar </ string> 6</ Recursos>

Nuestro elemento de la lista (única fila en la lista) tiene un diseño personalizado, así, que se define en el archivo de row.xml: 1 2 3 4 5 6

<? Xml version = "1.0" encoding = "UTF-8"?> <LinearLayout xmlns: android = "http://schemas.android.com/apk/res/android" android: layout_width = "fill_parent" android: layout_height = "android: attr / listPreferredItemHeight" Android: padding = "6DIP"> <ImageView

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 7 android: id = "+ id @ / icono" 8 android: layout_width = "wrap_content" 9 android: layout_height = "fill_parent" 10android: layout_marginRight = "6DIP" 11android: src = "@ dibujable / icono" /> 12<LinearLayout 13android: orientation = "vertical" 14android: layout_width = "0dip" 15android: layout_weight = "1" 16android: layout_height = "fill_parent"> 17<TextView 18android: id = "+ id @ / TopText" 19android: layout_width = "fill_parent" 20android: layout_height = "0dip" 21android: layout_weight = "1" 22Android: la gravedad = "center_vertical" 23/> 24<TextView 25android: layout_width = "fill_parent" 26android: layout_height = "0dip" 27android: layout_weight = "1" 28android: id = "+ id @ / bottomtext" 29android: SingleLine = "true" 30Android: la elipsis = "carpa" 31/> 32</ LinearLayout> 33</ LinearLayout>

Ok, así que tenemos todos nuestros diseños se define en la carpeta de resolución en el diseño. Ahora es el momento para volver a nuestro código y crear nuestra clase OrderAdapter personalizado que se encargará de nuestra lista de pedidos: 1 clase privada OrderAdapter extends ArrayAdapter <Order> { 2 3 privada ArrayList <Order> artículos; 4 5 OrderAdapter públicos (contexto contexto, int textViewResourceId, ArrayList <Order> artículos)

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 6 { 7 super (contexto, textViewResourceId, artículos); 8 estos elementos = elementos.; 9 } 10 11@ Override 12Vista pública getView (int posición, Ver convertView, padre ViewGroup) { 13Ver v = convertView; 14if (v == null) { 15LayoutInflater vi = (LayoutInflater) getSystemService (Contexto LAYOUT_INFLATER_SERVICE.); 16. v = vi inflar (R. diseño fila, nulo.); 17} 18Solicitar o = obtener elementos (posición).; 19if (O! = null) { 20TextView tt = (TextView) v findViewById (R. Identificación TopText.); 21TextView bt = (TextView) v findViewById (R. Identificación bottomtext.); 22if (tt! = null) { 23. tt setText ("Nombre:". + o getOrderName ());} 24if (bt! = null) { 25. bt setText ("Estado:". + o getOrderStatus ()); 26} 27} 28volver V; 29} }

Esta es una clase privada y debe ser añadido a nuestra SoftwarePassionView. Esto es ListAdapter extendidas que en el interior overriden método getView devuelve nuestra fila con los valores de cadena asignada a los campos de texto definidos en row.xml.

Una gran parte de nuestra aplicación ya está hecho. Ahora tenemos que añadir algunas modificaciones en el método OnCreate para inicializar todo correctamente y agregar un método de recuperación de los pedidos de algún lado, vamos a empezar con este último: 1 GetOrders private void () { 2 try { 3 m_orders = new ArrayList <Order> ();

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 4 Orden o1 = nueva orden (); 5 o1 setOrderName ("servicios de SF").; 6 o1 setOrderStatus ("pendiente").; 7 Orden o2 = new Orden (); 8 . O2 setOrderName ("Publicidad SF"); 9 o2 setOrderStatus ("Completo").; 10m_orders. añadir (o1); 11m_orders. añadir (O2); 12. Tema del sueño (2000); 13. Entrar i (. "Array", "" + m_orders tamaño ()); 14} Catch (Exception e) { 15Entrar e ("BACKGROUND_PROC", e getMessage ().).; 16} 17runOnUiThread (returnRes); 18}

En lugar de crear nuestras órdenes simples en el método anterior se puede, por supuesto, descargarlos de algún sitio y asignar el resultado a la lista de arreglo m_orders. El runOnUIThread método es un método de utilidad para la ejecución de tareas de nuevo en el hilo de interfaz de usuario principal después de que el trabajo se realiza en el subproceso independiente creado para grandes tareas en ejecución. Vamos a llamar a nuestro método GetOrders de un hilo separado.

El ejecutable returnRes agrega objeto recién recuperado el orden en nuestro adaptador de la costumbre y la notifica del cambio de los datos: 1 privadas returnRes ejecutables = new Runnable () { 2 3 @ Override 4 public void run () { 5 if (m_orders! = null && m_orders. size ()> 0) { 6 m_adapter notifyDataSetChanged ().; 7 for (int i = 0; i <m_orders size ();. i + +) 8 m_adapter añadir (m_orders. get (i)).; 9 } 10. m_ProgressDialog despedir a ();

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 11m_adapter notifyDataSetChanged ().; 12} 13};

Ahora vamos a pasar a nuestro método onCreate sobreescrito. Vamos a iniciar aquí todas las variables miembro, así como iniciar un nuevo hilo de recuperar nuestros pedidos: 1 @ Override 2 onCreate public void (paquete savedInstanceState) { 3 . súper onCreate (savedInstanceState); 4 setContentView (R. diseño principal.); 5 m_orders = new ArrayList <Order> (); 6 este m_adapter = OrderAdapter nuevas (esto, el diseño R. fila, m_orders.).; 7 setListAdapter (este m_adapter.); 8 9 viewOrders = new Runnable () { 10@ Override 11public void run () { 12GetOrders (); 13} 14}; 15Tema hilo = new Thread (null, viewOrders, "MagentoBackground"); 16. Fecha de Inicio (); 17m_ProgressDialog = ProgressDialog. show (SoftwarePassionView. esto, 18"Por favor, espera ...", "Recuperación de datos ...", true); 19}

Después de la inicialización, se inicia nuevo hilo con los viewOrders ejecutables y mostrar el diálogo de progreso que se cerrará una vez que las órdenes se recuperan.

Ahora usted debería ser capaz de ejecutar la aplicación. Después se inicia la aplicación que genera nuevo hilo y muestra el cargador:

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Y eso es. Se puede añadir un detector de Haga clic en elemento a la lista para iniciar nuevas actividades, etc El código fuente completo para el SoftwarePassionView a continuación: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

paquete de com.softberries.lve; java.util.ArrayList importación; importar android.app.ListActivity; android.app.ProgressDialog importación; importar android.content.Context; android.os.Bundle importación; importar android.util.Log; importar android.view.LayoutInflater; importar android.view.View; importar android.view.ViewGroup; android.widget.ArrayAdapter de importación; importar android.widget.TextView; pública SoftwarePassionView clase extiende ListActivity { privada ProgressDialog m_ProgressDialog = null;

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

privada ArrayList <Order> m_orders = null; privada OrderAdapter m_adapter; privadas viewOrders ejecutables; @ Override onCreate public void (paquete savedInstanceState) { . súper onCreate (savedInstanceState); setContentView (R. diseño principal.); m_orders = new ArrayList <Order> (); este m_adapter = OrderAdapter nuevas (esto, el diseño R. fila, m_orders.).; setListAdapter (este m_adapter.); viewOrders = new Runnable () { @ Override public void run () { GetOrders (); } }; Tema hilo = new Thread (null, viewOrders, "MagentoBackground"); . Fecha de Inicio (); m_ProgressDialog = ProgressDialog. show (SoftwarePassionView. esto, "Por favor, espera ...", "Recuperación de datos ...", true); } privadas returnRes ejecutables = new Runnable () { @ Override public void run () { if (m_orders! = null && m_orders. size ()> 0) { m_adapter notifyDataSetChanged ().; for (int i = 0; i <m_orders size ();. i + +) m_adapter añadir (m_orders. get (i)).; } . m_ProgressDialog despedir a (); m_adapter notifyDataSetChanged ().; } }; GetOrders private void () {

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

try { m_orders = new ArrayList <Order> (); Orden o1 = nueva orden (); o1 setOrderName ("servicios de SF").; o1 setOrderStatus ("pendiente").; Orden o2 = new Orden (); . O2 setOrderName ("Publicidad SF"); o2 setOrderStatus ("Completo").; m_orders. añadir (o1); m_orders. añadir (O2); . Tema del sueño (5000); . Entrar i (. "Array", "" + m_orders tamaño ()); } Catch (Exception e) { Entrar e ("BACKGROUND_PROC", e getMessage ().).; } runOnUiThread (returnRes); } clase privada OrderAdapter extends ArrayAdapter <Order> { privada ArrayList <Order> artículos; OrderAdapter públicos (contexto contexto, int textViewResourceId, ArrayList <Order> artículos) { super (contexto, textViewResourceId, artículos); estos elementos = elementos.; } @ Override Vista pública getView (int posición, Ver convertView, padre ViewGroup) { Ver v = convertView; if (v == null) { LayoutInflater vi = (LayoutInflater) getSystemService (Contexto LAYOUT_INFLATER_SERVICE.); . v = vi inflar (R. diseño fila, nulo.); } Solicitar o = obtener elementos (posición).; if (O! = null) { TextView tt = (TextView) v findViewById (R. Identificación TopText.); TextView bt = (TextView) v findViewById (R. Identificación bottomtext.);

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 92 if (tt! = null) { 93 . tt setText ("Nombre:". + o getOrderName ());} 94 if (bt! = null) { 95 . bt setText ("Estado:". + o getOrderStatus ()); 96 } 97 } 98 volver V; 99 } 100} }

Fuente: http://www.softwarepassion.com/android-series-custom-listview-items-andadapters/

CheckBox

Es un tipo de botón con dos estados, activo o inactivo, prácticamente tiene el mismo comportamiento de un botón, una de sus características es que podemos comprobar si el botón esta activo o no.

Una casilla de verificación es un tipo específico de dos estados de botón que puede ser ya sea activada o desactivada. Un ejemplo de uso de una casilla de verificación dentro de su actividad sería la siguiente: Codigo checkBox1=(CheckBox)findViewById(R.id.checkBox1); checkBox2=(CheckBox)findViewById(R.id.checkBox2); String resu=""; if (checkBox1.isChecked()==true) {

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” int suma=nro1+nro2; resu="La suma es: "+ suma; } if (checkBox2.isChecked()==true) { int resta=nro1-nro2; resu=resu + " La resta es: "+ resta; } tv3.setText(resu);

Fuente: http://developer.android.com/reference/android/widget/CheckBox.html

Toast Un toast es un mensaje que se muestra en pantalla durante unos segundos al usuario para luego volver a desaparecer automáticamente sin requerir ningún tipo de actuación por su parte, y sin recibir el foco en ningún momento (o dicho de otra forma, sin interferir en las acciones que esté realizando el usuario en ese momento). Aunque son personalizables, aparecen por defecto en la parte inferior de la pantalla, sobre un rectángulo gris ligeramente translúcido. Por sus propias características, este tipo de notificaciones son ideales para mostrar mensajes rápidos y sencillos al usuario, pero por el contrario, al no requerir confirmación por su parte, no deberían utilizarse para hacer notificaciones demasiado importantes.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Su utilización es muy sencilla, concentrándose toda la funcionalidad en la clase Toast.

Esta clase dispone de un método estático makeText() al que deberemos pasar como parámetro el contexto de la actividad, el texto a mostrar, y la duración del mensaje, que puede tomar los valores LENGTH_LONG o LENGTH_SHORT, dependiendo del tiempo que queramos que la notificación aparezca en pantalla. Tras obtener una referencia al objeto Toast a través de este método, ya sólo nos quedaría mostrarlo en pantalla mediante el método show().

Vamos a construir una aplicación de ejemplo para demostrar el funcionamiento de este tipo de notificaciones. Y para empezar vamos a incluir un botón que muestre un toast básico de la forma que acabamos de describir: 1 2 btnDefecto.setOnClickListener(new OnClickListener() { @Override 3 public void onClick(View arg0) { 4 Toast toast1 = Toast.makeText(getApplicationContext(), 5 "Toast por defecto", Toast.LENGTH_SHORT); 6 7 toast1.show(); 8 } 9 }); 10 Si ejecutamos esta sencilla aplicación en el emulador y pulsamos el botón que acabamos de añadir veremos como en la parte inferior de la pantalla aparece el mensaje “Toast por defecto”, que tras varios segundos desaparecerá automáticamente.

Como hemos comentado, éste es el comportamiento por defecto de las notificaciones toast, sin embargo también podemos personalizarlo un poco cambiando su posición en la pantalla. Para esto utilizaremos el método setGravity(), al que podremos indicar en qué zona deseamos que aparezca la notificación. La zona deberemos indicarla con alguna de las constantes definidas en la clase Gravity: CENTER, LEFT, BOTTOM, … o con alguna combinación de éstas.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Para nuestro ejemplo vamos a colocar la notificación en la zona central izquierda de la pantalla. Para ello, añadamos un segundo botón a la aplicación de ejemplo que muestre un toast con estas características: Si esto no es suficiente y necesitamos personalizar por completo el aspecto de la notificación, Android nos ofrece la posibilidad de definir un layout XML para toast, donde podremos incluir todos elementos necesarios para adaptar la notificación a nuestras necesidades. para ejemplo vamos a definir un layout con una imagen y una etiqueta de texto rectángulo gris.

propio los nuestro sencillo, sobre un

Fuente: http://www.sgoliver.net/blog/?p=1991

ArrayAdapter Un control ListView muestra al usuario una lista de opciones seleccionables directamente sobre el propio control, sin listas emergentes como en el caso del control Spinner. En caso de existir más opciones de las que se pueden mostrar sobre el control se podrá por supuesto hacer scroll sobre la lista para acceder al resto de elementos.

Para empezar, veamos como podemos añadir un control ListView a nuestra interfaz de usuario: <ListView android:id="@+id/LstOpciones" android:layout_width="wrap_content" android:layout_height="wrap_content" />

Una vez más, podremos modificar el aspecto del control utilizando las propiedades de fuente y color ya comentadas en artículos anteriores. Por su parte, para enlazar los datos con el control podemos utlizar por ejemplo el mismo código que ya vimos para el control Spinner. Definiremos primero un array con nuestros datos de prueba, crearemos

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” posteriormente el adaptador de tipo ArrayAdapter y lo asignaremos finalmente al control mediante el método setAdapter(): final String[] datos = new String[]{"Elem1","Elem2","Elem3","Elem4","Elem5"}; ArrayAdapter<String> adaptador = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, datos); ListView lstOpciones = (ListView)findViewById(R.id.LstOpciones); lstOpciones.setAdapter(adaptador);

En este caso, para mostrar los datos de cada elemento hemos utilizado otro layout genérico de Android para los controles de tipo ListView (android.R.layout.simple_list_item_1), formado únicamente por un TextView con unas dimensiones determinadas. La lista creada quedaría como se muestra en la imagen siguiente:

Como podéis comprobar el uso básico del control ListView es completamente análogo al ya comentado para el control Spinner.

Si quisiéramos realizar cualquier acción al pulsarse sobre un elemento de la lista creada tendremos que implementar el evento onItemClick. Veamos cómo con un ejemplo:

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” lstOpciones.setOnItemClickListener(new OnItemClickListener() { @Override public void onItemClick(AdapterView<?> a, View v, int position, long id) { //Acciones necesarias al hacer click } });

Hasta aquí todo sencillo. Pero, ¿y si necesitamos mostrar datos más complejos en la lista? ¿Qué ocurre si necesitamos que cada elemento de la lista esté formado a su vez por varios elementos? Pues vamos a provechar este artículo dedicado a los ListView para ver cómo podríamos conseguirlo, aunque todo lo que comentaré es extensible a otros controles de selección.

Para no complicar mucho el tema vamos a hacer que cada elemento de la lista muestre por ejemplo dos líneas de texto a modo de título y subtítulo con formatos diferentes (por supuesto se podrían añadir muchos más elementos, por ejemplo imágenes, checkboxes, etc).

En primer lugar vamos a crear una nueva clase java para contener nuestros datos de prueba.

Vamos a llamarla Titular y tan sólo va a contener dos atributos, título y subtítulo. package net.sgoliver; public class Titular { private String titulo; private String subtitulo; public Titular(String tit, String sub){ titulo = tit; subtitulo = sub; } public String getTitulo(){ return titulo; } public String getSubtitulo(){ return subtitulo; } }

En cada elemento de la lista queremos mostrar ambos datos, por lo que el siguiente paso será crear un layout XML con la estructura que deseemos. En mi caso voy a mostrarlos en dos etiquetas de texto (TextView), la primera de ellas en negrita y con un tamaño de letra un poco mayor. Llamaremos a este layout “listitem_titular.xml“:

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="wrap_content" android:layout_height="wrap_content" android:orientation="vertical"> <TextView android:id="@+id/LblTitulo" android:layout_width="fill_parent" android:layout_height="wrap_content" android:textStyle="bold" android:textSize="20px" /> <TextView android:id="@+id/LblSubTitulo" android:layout_width="fill_parent" android:layout_height="wrap_content" android:textStyle="normal" android:textSize="12px" /> </LinearLayout>

Ahora que ya tenemos creados tanto el soporte para nuestros datos como el layout que necesitamos para visualizarlos, lo siguiente que debemos hacer será indicarle al adaptador cómo debe utilizar ambas cosas para generar nuestra interfaz de usuario final. Para ello vamos a crear nuestro propio adaptador extendiendo de la clase ArrayAdapter. class AdaptadorTitulares extends ArrayAdapter { Activity context; AdaptadorTitulares(Activity context) { super(context, R.layout.listitem_titular, datos); this.context = context; } public View getView(int position, View convertView, ViewGroup parent) { LayoutInflater inflater = context.getLayoutInflater(); View item = inflater.inflate(R.layout.listitem_titular, null); TextView lblTitulo = (TextView)item.findViewById(R.id.LblTitulo); lblTitulo.setText(datos[position].getTitulo()); TextView lblSubtitulo = (TextView)item.findViewById(R.id.LblSubTitulo); lblSubtitulo.setText(datos[position].getSubtitulo());

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

return(item); } }

Analicemos el código anterior. Lo primero que encontramos es el constructor para nuestro adaptador, al que sólo pasaremos el contexto (que será la actividad desde la que se crea el adaptador). En este constructor tan sólo guardaremos el contexto para nuestro uso posterior y llamaremos al constructor padre tal como ya vimos al principio de este artículo, pasándole el ID del layout que queremos utilizar (en nuestro caso el nuevo que hemos creado, “listitem_titular”) y el array que contiene los datos a mostrar.

Posteriormente, redefinimos el método encargado de generar y rellenar con nuestros datos todos los controles necesarios de la interfaz gráfica de cada elemento de la lista. Este método es getView().

El método getView() se llamará cada vez que haya que mostrar un elemento de la lista. Lo primero que debe hacer es “inflar” el layout XML que hemos creado. Esto consiste en consultar el XML de nuestro layout y crear e inicializar la estructura de objetos java equivalente. Para ello, crearemos un nuevo objeto LayoutInflater y generaremos la estructura de objetos mediante su método inflate(id_layout).

Tras esto, tan sólo tendremos que obtener la referencia a cada una de nuestras etiquetas como siempre lo hemos hecho y asignar su texto correspondiente según los datos de nuestro array y la posición del elemento actual (parámetro position del método getView()).

Una vez tenemos definido el comportamiento de nuestro adaptador la forma de proceder en la actividad principal será análoga a lo ya comentado, definiremos el array de datos de prueba, crearemos el adaptador y lo asignaremos al control mediante setAdapter(): private Titular[] datos = new Titular[]{ new Titular("Título new Titular("Título new Titular("Título new Titular("Título new Titular("Título

1", 2", 3", 4", 5",

"Subtítulo "Subtítulo "Subtítulo "Subtítulo "Subtítulo

largo largo largo largo largo

1"), 2"), 3"), 4"), 5")};

//... //...

AdaptadorTitulares adaptador = new AdaptadorTitulares(this); ListView lstOpciones = (ListView)findViewById(R.id.LstOpciones);

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

lstOpciones.setAdapter(adaptador);

Hecho esto, y si todo ha ido bien, nuestra nueva lista debería quedar como vemos en la imagen siguiente:

Aunque ya sabemos utilizar y personalizar las listas en Android, en el próximo artículo daremos algunas indicaciones para utilizar de una forma mucho más eficiente los controles de este tipo, algo que los usuarios de nuestra aplicación agradecerán enormemente al mejorarse la respuesta de la aplicación y reducirse el consumo de batería.

Descripción de la clase A BaseAdapter concretas que está respaldado por una gran variedad de objetos arbitrarios.

Por defecto esta clase espera que las referencias de recursos proporcionados id TextView una sola. Si desea utilizar un diseño más complejo, el uso de los constructores que también se toma un identificador de campo. Eso Identificación del campo debe hacer referencia a una TextView en el recurso de diseño más grande.

Sin embargo, la TextView se hace referencia, que se llenará con el método toString () de cada objeto en la matriz. Usted puede agregar listas o matrices de objetos personalizados.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Reemplace el método toString () de los objetos para determinar qué texto se mostrará para el elemento de la lista.

Para usar otra cosa que TextViews para la pantalla de matriz, por ejemplo, ImageViews, o para que algunos de los datos, además de toString () resulta llenar los puntos de vista, reemplace getView(int, View, ViewGroup) para devolver el tipo de vista que desee.

Resumen Constantes heredados Desde la interfaz de android.widget.Adapter Constructores públicos ArrayAdapter ( contexto contexto, int textViewResourceId) Constructor ArrayAdapter ( contexto contexto, los recursos, int textViewResourceId) Constructor ArrayAdapter ( contexto contexto, int textViewResourceId, T [] objetos) Constructor ArrayAdapter ( contexto contexto, los recursos int, int textViewResourceId, T [] objetos) Constructor ArrayAdapter ( contexto contexto, int textViewResourceId, Lista de objetos <T>) Constructor ArrayAdapter ( contexto contexto, los recursos, int textViewResourceId, Lista de objetos <T>) Constructor Métodos públicos anular anular anular

anular estática

agregar (T objeto) Agrega el objeto especificado en el extremo de la matriz. addAll ( Colección <? extends T> colección) Agrega la colección especificada al final de la matriz. addAll (T. .. artículos) Agrega los elementos especificados en el final de la matriz. claro () Retire todos los elementos de la lista. createFromResource ( contexto contexto, int

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” ArrayAdapter textArrayResId, int textViewResId) < Crea un ArrayAdapter nuevos recursos externos.

CharSequence > Contexto getContext () Devuelve el contexto asociado con este adaptador de matriz. int GetCount () Ver getDropDownView (int posición, Ver convertView, ViewGroup los padres)

Obtener una View que se muestra en el menú desplegable de los datos emergentes en la posición especificada en el conjunto de datos.

Filtrar

getFilter ()

Devuelve un filtro que puede ser utilizado para restringir los datos con un patrón de filtrado.

T largo int

Ver anular

anular

anular anular

getItem (posición int) getItemId (posición int) getPosition (T elemento) Devuelve la posición del elemento especificado en la matriz. getView (int posición, Ver convertView, ViewGroup los padres) inserción (objeto T, int index) Inserta el objeto especificado en el índice especificado de la matriz. notifyDataSetChanged () Notifica a los observadores que los datos adjuntos subyacente se ha cambiado y cualquier vista que refleja el conjunto de datos que se actualice. eliminar (T objeto) Quita el objeto especificado de la matriz. setDropDownViewResource (recurso int)

Establece el recurso de diseño para crear el menú desplegable de puntos de vista. anular

setNotifyOnChange (boolean notifyOnChange) Control de si los métodos que cambian la lista ( add(T) , insert(T, int) , remove(T) , clear() ) llama

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” automáticamente a notifyDataSetChanged() . anular tipo ( Comparador <? Super T> comparador) Ordena el contenido de este adaptador utilizando el comparador especificado.

Métodos heredados De clase android.widget.BaseAdapter Desde la clase java.lang.Object Desde la interfaz de android.widget.Adapter Desde la interfaz android.widget.Filterable Desde la interfaz de android.widget.ListAdapter Desde la interfaz de android.widget.SpinnerAdapter

Htttp: http://sudarmuthu.com/blog/using-arrayadapter-and-listview-in-android-applications http://www.sgoliver.net/blog/?p=1414

AlertDialog Un AlertDialog es una extensión del Dialog de clase. Es capaz de construir interfaces de usuario más diálogo y es el tipo de diálogo propuesto. Usted debe utilizar para los cuadros de diálogo que utilizan alguna de las siguientes características:    

Un título Un mensaje de texto Uno, dos, o tres botones Una lista de elementos seleccionables (con casillas o botones de radio opcional)

Para crear un AlertDialog, utiliza el AlertDialog.Builder subclase. Obtener un constructor con AlertDialog.Builder(Context) y luego usar los métodos públicos de la clase para definir todas las propiedades AlertDialog. Después de que hayas terminado con el Creador, recuperar el objeto AlertDialog con create() .

Los temas siguientes se muestran cómo definir varias propiedades de la AlertDialog con la clase AlertDialog.Builder. Si utiliza cualquiera de las siguiente código de ejemplo dentro de

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” su onCreateDialog() el método de devolución de llamada, usted puede devolver el objeto resultante de diálogo para mostrar el cuadro de diálogo.

Agregar botones

Para crear un AlertDialog con los botones de lado a lado como el que se muestra en la imagen a la derecha, utilice el set...Button() métodos: AlertDialog.Builder constructor = new AlertDialog.Builder (este); builder.setMessage ("¿Está seguro que desea salir?") . SetCancelable (falso) . SetPositiveButton ("Sí", DialogInterface.OnClickListener nuevo () { public void onClick (DialogInterface de diálogo, int id) { MyActivity.this.finish (); } }) . SetNegativeButton ("No", DialogInterface.OnClickListener nuevo () { public void onClick (DialogInterface de diálogo, int id) { dialog.cancel (); } }); AlertDialog alerta builder.create = ();

En primer lugar, añadir un mensaje para el diálogo con setMessage(CharSequence) . A continuación, comenzará el método de encadenamiento y establecer el diálogo para no ser cancelable (por lo que el usuario no puede cerrar el diálogo con el botón de retroceso) con setCancelable(boolean) . Para cada botón, utilice uno de los set...Button() los métodos, tales como setPositiveButton() , que acepta el nombre del botón y un DialogInterface.OnClickListener que define la acción a realizar cuando el usuario selecciona el botón.

Nota: Sólo se puede añadir uno de cada tipo de botón a la AlertDialog. Es decir, no se puede tener más de un resultado "positivo" el botón. Esto limita el número de botones posibles a tres: positivo, neutro y negativo. Estos nombres son técnicamente irrelevante para la funcionalidad real de los botones, sino que debe ayudar a no perder de vista que uno hace lo que pase.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Adición de una lista

Para crear un AlertDialog con una lista de elementos seleccionables como el que se muestra a la derecha, utilice los setItems() método: CharSequence final [] = {elementos "Rojo", "Verde", "Azul"}; AlertDialog.Builder constructor = new AlertDialog.Builder (este); builder.setTitle ("Elija un color"); builder.setItems (artículos, DialogInterface.OnClickListener nuevo () { public void onClick (DialogInterface de diálogo, int elemento) { . Toast.makeText (getApplicationContext (), los artículos [tema], Toast.LENGTH_SHORT) show (); } }); AlertDialog alerta builder.create = ();

En primer lugar, añadir un título al cuadro de diálogo con setTitle(CharSequence) . A continuación, agregue una lista de elementos seleccionables con setItems() , que acepte el arreglo de elementos para mostrar y una DialogInterface.OnClickListener que define la acción a realizar cuando el usuario selecciona un elemento.

Adición de casillas de verificación y botones de radio

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Para crear una lista de ítems de opción múltiple (casillas) o un solo ítems de opción (botones de radio) en el interior del cuadro de diálogo, utilice los setMultiChoiceItems() y setSingleChoiceItems() los métodos, respectivamente. Si se crea una de estas listas seleccionables en el onCreateDialog() método de devolución de llamada, Android gestiona el estado de la lista para usted. Mientras que la actividad está activa, el diálogo recuerda los artículos que fueron seleccionados previamente, pero cuando el usuario sale de la actividad, la selección se ha perdido.

Nota: Para guardar la selección cuando el usuario se va o se detiene la actividad, que adecuadamente debe guardar y restaurar la configuración de todo el ciclo de vida de la actividad . Para guardar de forma permanente las selecciones, incluso cuando el proceso de la actividad es completamente apagado, usted necesita para guardar los ajustes con una de las de almacenamiento de datos técnicas.

Para crear un AlertDialog con una sola lista de ítems de selección como la que aparece a la derecha, usar el mismo código del ejemplo anterior, pero sustituyendo los setItems() método con setSingleChoiceItems() : CharSequence final [] = {elementos "Rojo", "Verde", "Azul"}; AlertDialog.Builder constructor = new AlertDialog.Builder (este); builder.setTitle ("Elija un color"); builder.setSingleChoiceItems (artículos, DialogInterface.OnClickListener -1, el nuevo () { public void onClick (DialogInterface de diálogo, int elemento) { . Toast.makeText (getApplicationContext (), los artículos [tema], Toast.LENGTH_SHORT) show (); } }); AlertDialog alerta builder.create = ();

El segundo parámetro en las setSingleChoiceItems() el método es un valor entero para el checkedItem, lo que indica la posición de la lista de base cero del elemento por defecto seleccionado. Use "-1" para indicar que no hay ningún elemento debe ser seleccionada por defecto.

Creación de un ProgressDialog

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Un ProgressDialog es una extensión de la AlertDialog clase que puede mostrar una animación de progreso en la forma de una rueda giratoria, para una tarea con el progreso que es indefinido, o una barra de progreso, para una tarea que tiene una progresión definida.

El diálogo también puede proporcionar botones, como una de cancelar una descarga.

La apertura de un diálogo de progreso puede ser tan simple como llamar a ProgressDialog.show() . Por ejemplo, el diálogo de progreso muestra a la derecha se puede conseguir fácilmente sin lograr el diálogo a través de la onCreateDialog(int) de devolución de llamada, como se muestra aquí: De diálogo ProgressDialog = ProgressDialog.show (MyActivity.this, "", "Cargando Por favor, espere ..."., True);

El primer parámetro es la aplicación Context , el segundo es un título para el cuadro de diálogo (se deja vacío), el tercero es el mensaje, y el último parámetro es si el progreso es indeterminado (esto sólo es relevante cuando se crea una barra de progreso, que es discutido en la próxima sección).

El estilo por defecto de un diálogo de progreso es la rueda que gira. Si desea crear una barra de progreso que muestra el progreso de la carga con una granularidad, el código se requiere un poco más, como se explica en la siguiente sección.

Mostrando una barra de progreso

Para mostrar la progresión con una barra de progreso animada: 1. Inicializar el ProgressDialog con el constructor de la clase, ProgressDialog(Context) .

2. Defina el estilo de los avances a "STYLE_HORIZONTAL" con setProgressStyle(int) y establecer otras propiedades, tales como el mensaje.

3. Cuando esté listo para mostrar el cuadro de diálogo, llame a show() o devolver el ProgressDialog de la onCreateDialog(int) de devolución de llamada.

4. Usted puede incrementar la cantidad de progreso que se muestra en la barra o bien llamando al setProgress(int) con un valor para el porcentaje total completado hasta ahora o incrementProgressBy(int) con un valor incremental de añadir al porcentaje total realizado hasta ahora.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Por ejemplo, la configuración podría tener este aspecto: ProgressDialog progressDialog; progressDialog = new ProgressDialog (mContext); progressDialog.setProgressStyle (ProgressDialog.STYLE_HORIZONTAL); progressDialog.setMessage ("Cargando ..."); progressDialog.setCancelable (false);

La configuración es simple. La mayor parte del código necesario para crear un diálogo de progreso está realmente involucrado en el proceso que lo actualiza. Usted podría encontrar que es necesario crear un segundo hilo de la aplicación de este trabajo y luego informar de los avances de nuevo a la interfaz de usuario hilo de la actividad con un Handler objeto. Si usted no está familiarizado con el uso de las discusiones adicionales con un controlador, consulte el siguiente ejemplo de actividad que utiliza un segundo hilo para incrementar un diálogo de progreso logrado por la actividad.

Ejemplo ProgressDialog con un segundo hilo

Creación de un cuadro de diálogo personalizado

Si desea un diseño personalizado para un cuadro de diálogo, puede crear su propio diseño de la ventana de diálogo con el diseño y los elementos de widgets. Después de haber definido el diseño, pase el objeto View raíz o identificador de recursos de diseño para setContentView(View) .

Por ejemplo, para crear el diálogo que se muestra a la derecha: 1. Crear un diseño de XML guardado como custom_dialog.xml : 2.

<LinearLayout xmlns: android = "http://schemas.android.com/apk/res/android" 3. android: id = "+ id @ / layout_root" 4. android: orientation = "horizontal" 5. android: layout_width = "fill_parent" 6. android: layout_height = "fill_parent" 7.

Android: padding = "10DP" 8. > 9. <ImageView android: id = "+ id @ / imagen" 10. android: layout_width = "wrap_content"

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 11.

12.

13.

14.

15.

16.

17.

18.

19.

android: layout_height = "fill_parent" android: layout_marginRight = "10DP" /> <TextView android: id = "+ id @ / texto" android: layout_width = "wrap_content" android: layout_height = "fill_parent" android: textColor = "# FFF" /> </ LinearLayout>

Este XML define un ImageView y un TextView dentro de un LinearLayout .

20. Establezca el diseño por encima de vista de contenido como el diálogo y definir el contenido de la ImageView y elementos TextView: 21.

22.

23.

24.

25.

26.

27.

28.

29.

Contexto mContext getApplicationContext = (); De diálogo de diálogo = nuevo cuadro de diálogo (mContext); dialog.setContentView (R.layout.custom_dialog); dialog.setTitle ("cuadro de diálogo personalizado");

Vista de Texto text = (TextView) dialog.findViewById (R.id.text); text.setText ("Hola, este es un diálogo personalizado"); ImageView la imagen = (ImageView) dialog.findViewById (R.id.image); 30. image.setImageResource (R.drawable.android);

Después de crear una instancia del diálogo, poner tu diseño personalizado, como ver el contenido del cuadro de diálogo con setContentView(int) , pasándole el identificador de recursos de diseño. Ahora que el diálogo tiene un diseño definido, puede capturar objetos Vista desde el diseño con findViewById(int) y modificar su contenido.

31. Eso es todo. Ahora puede mostrar el diálogo como se describe en un cuadro de diálogo Mostrando .

Un diálogo hecho con la clase de diálogo de base debe tener un título. Si usted no llama setTitle() , entonces el espacio utilizado por el título se queda vacío, pero aún visible. Si usted no desea un título para nada, entonces usted debe crear su diálogo personalizado utilizando el AlertDialog clase. Sin embargo, debido a que un AlertDialog se crea más fácil con la AlertDialog.Builder clase, usted no tiene acceso a la setContentView(int) método utilizado anteriormente. En su lugar, debe utilizar setView(View) . Este método acepta un View objeto, por lo que necesita para inflar el objeto de diseño raíz de Vista a partir de XML.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Para inflar el esquema XML, recuperar el LayoutInflater con getLayoutInflater() (o getSystemService() ), y luego llamar a inflate(int, ViewGroup) , donde el primer parámetro es el identificador de recursos de diseño y el segundo es el ID de la vista de la raíz. En este punto, puede utilizar el diseño de inflado para encontrar objetos Ver en el diseño y definir el contenido de la ImageView y elementos TextView. A continuación, una instancia de la AlertDialog.Builder y establecer el diseño de inflado para el diálogo con setView(View) .

He aquí un ejemplo, la creación de un diseño personalizado en un AlertDialog: AlertDialog.Builder constructor; AlertDialog alertDialog; Contexto mContext getApplicationContext = (); LayoutInflater inflater = (LayoutInflater) mContext.getSystemService (LAYOUT_INFLATER_SERVICE); Ver layout = inflater.inflate (R.layout.custom_dialog, (ViewGroup) findViewById (R.id.layout_root)); Vista de Texto text = (TextView) layout.findViewById (R.id.text); text.setText ("Hola, este es un diálogo personalizado"); ImageView la imagen = (ImageView) layout.findViewById (R.id.image); image.setImageResource (R.drawable.android); constructor = new AlertDialog.Builder (mContext); builder.setView (diseño); alertDialog builder.create = ();

El uso de un AlertDialog para su diseño personalizado le permite tomar ventaja de las características incorporadas de AlertDialog como botones, listas seleccionables gestionados, un título, un icono y así sucesivamente.

Fuente: http://blog.stylingandroid.com/archives/271

LayountInflater Android es la creación de todos los objetos de vista contenidos en la estructura del archivo XML proporcionado a la setContentView(int layoutResId) método. Este proceso de creación de objetos de vista de los recursos de diseño que se conoce como la inflación de diseño.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Hasta aquí todo bien. Esto significa que antes de la setContentView(int layoutResId) se llama al método de la findViewById(int resId) método devolverá null para las referencias de vista en el diseño, causando un potencial NullpointerExceptions . @ Override onCreate public void (paquete savedInstanceState) { . súper onCreate (savedInstanceState); EditarTexto addressField = (EditarTexto) findViewById (R. Identificación de direcciones.) / / A principios de! Devolverá un valor nulo setContentView (R. diseño principal.); Button boton = ( Button ) findViewById (R. Identificación launchMap.); . addressField setText ("texto"); / / NullPointerException . botón de setText ("otro texto"); / / No hay problema }

Para evitar estos errores es un buen hábito para colocar el setContentView(int layoutResId) llamada al método en la parte superior de la onCreate() método.

En algunos casos, usted tendrá que hacer el diseño de la inflación por sí mismo, es decir, cuando desea configurar una vista personalizada de un Dialog o una Toast . Para inflar el fin de utilizar el LayoutInflater clase. Hay un número de maneras diferentes de obtener un identificador de un LayoutInflater : LayoutInflater inflater = (LayoutInflater) contexto. GetSystemService ( Contexto LAYOUT_INFLATER_SERVICE).; LayoutInflater inflater = LayoutInflater de (contexto).;

Para crear realmente el objeto de la vista se utiliza el método inflate () de la LayoutInflater.

En la forma más sencilla este método tiene la firma: pública Ver inflar (recurso int raíz, ViewGroup)

Tenga en cuenta que el recurso se refiere a un recurso de la estructura del archivo XML, no el id del objeto de la vista que desea inflar. En primer lugar inflar el diseño de recursos y luego obtener un identificador para el objeto de vista mediante la findViewById(int resId) método.

El segundo atributo le permite especificar un ViewGroup objeto a la vista raíz del objeto inflado (s) especificado por la distribución del archivo xml. Esto significa que el objeto visión exagerada (s) están unidos como las opiniones del niño en la raíz especificada

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” ViewGroup

objeto. Al establecer este valor como null simplemente devolver el objeto visión exagerada (s) sin asociar a un punto de vista de la raíz.

EditarTexto fooField = (EditarTexto) findViewById (R. Identificación foo.) / / A principios de! Devolverá un valor nulo LinearLayout myroot = new LinearLayout (); Ver ItemView = inflater inflar (diseño R. layout_details, myroot.);. / / desde layout_details.xml EditarTexto Barfield = (EditarTexto) findViewById (R. Identificación del bar.); / / Ahora tenemos un objeto

En este ejemplo el método de inflar devuelve el objeto mroot con los objetos de vista contenidos en el fichero layout_details.xml adjunta como vistas secundarias. Así ItemView y myroot se refiere en realidad al objeto físico.

Clases

LayoutInflater LayoutInflater(Context) : void LayoutInflater(LayoutInflater, Context) : void cloneInContext(Context) : LayoutInflater createView(String, String, AttributeSet) : View createViewFromTag(String, AttributeSet) : View failNotAllowed(String, String, AttributeSet) : void from(Context) : LayoutInflater getContext() : Context getFactory() : LayoutInflater.Factory getFilter() : LayoutInflater.Filter inflate(int, ViewGroup) : View inflate(XmlPullParser, ViewGroup) : View inflate(int, ViewGroup, boolean) : View inflate(XmlPullParser, ViewGroup, boolean) : View onCreateView(String, AttributeSet) : View parseInclude(XmlPullParser, View, AttributeSet) : void parseRequestFocus(XmlPullParser, View) : void rInflate(XmlPullParser, View, AttributeSet) : void setFactory(LayoutInflater.Factory) : void setFilter(LayoutInflater.Filter) : void DEBUG : boolean mConstructorArgs : Object[] mConstructorSignature : Class[]

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” mContext : Context mFactory : LayoutInflater.Factory mFactorySet : boolean mFilter : LayoutInflater.Filter mFilterMap : HashMap<String,Boolean> sConstructorMap : HashMap<String,Constructor> TAG_INCLUDE : String TAG_MERGE : String TAG_REQUEST_FOCUS : String Factory in LayoutInflater onCreateView(String, Context, AttributeSet) : View FactoryMerger in LayoutInflater FactoryMerger(LayoutInflater.Factory, LayoutInflater.Factory) : void onCreateView(String, Context, AttributeSet) : View mF1 : LayoutInflater.Factory mF2 : LayoutInflater.Factory Filter in LayoutInflater onLoadClass(Class) : boolean

Fuente: http://blog.jayway.com/2009/03/26/layout-resources-in-android/ http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2 _r1.1/android/view/LayoutInflater.java

Menu los menús. Algunos teléfonos Android tendrán una tecla dedicada a lanzar los menús dentro de una aplicación, mientras que otros ofrecerán maneras alternativas para lanzarlos.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” En Android existen tres tipos de menús que podemos utilizar dentro de nuestras aplicaciones: 





Menú de opciones: Es la colección primaria de ítems que aparecen en una actividad cuando el usuario oprime el botón MENU del dispositivo. En versiones más actuales como Android 3.0 y superiores, es posible proporcionar accesos rápidos para seleccionar ítems de un menú colocándolos directamente en la Action Bar mediante lo que se conoce como action ítems.

Menú contextual: Es un menú de opciones flotante en forma de lista que aparece cuando el usuario utiliza el gesto de taps-and-holds, es decir, de tocar la pantalla y mantener la pulsación por determinado tiempo, sobre algún componente de la interfaz de usuario.

Submenú: Es un menú de opciones flotante en forma de lista que aparece cuando el usuario selecciona un ítem de un menú que contiene otro menú anidado.

Creando un menú como recurso En Android, podemos diseñar varios tipos de recursos para incluirlos en nuestras aplicaciones; los menús no son la excepción. Para conseguirlo debemos crear un archivo XML con la definición del menú para después poderlos referenciar desde el código Java.

Manejar los menús de esta forma es una buena práctica porque nos permite separar el contenido del menú del código de nuestra aplicación. Así también, resulta más sencillo visualizar la estructura y el contenido del menú en un formato XML. Para crear un recurso de menú, se necesita de un archivo XML que guardaremos en el directorio res > menu con la siguiente estructura: <menu> Este elemento debe ser el nodo raíz del archivo. Crea un objeto Menu dentro del código. Puede contener uno o más elementos <item> y <group>. <item> Representa un ítem dentro del menú y en la parte del código crea un objeto de tipo MenuItem. Este elemento puede contener un elemento <menu> anidados que nos permitirá crear submenús. <group> Es un elemento opcional e invisible que podemos anidar dentro de un <item>.

Nos permite categorizar opciones que compartan propiedades tales como el estado activo/inactivo o visibilidad.

A continuación vamos a crear un recurso de menú en XML para que puedas visualizar su estructura:

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Como puedes observar el elemento raíz es <menu> con únicamente dos ítems. Para cada uno de ellos hemos definido un id, un icon que es un recurso de imagen almacenado en el directorio res > drawable y un título, que es el texto que desplegará cada opción y que tiene referencia a una cadena dentro del archivo strings.xml del directorio res > value.

Existen otros atributos que podemos definir dentro de los elementos <item>, puedes consultar esta lista desde la referencia de Menu Resource de la documentación oficial de Android Developers.

Utilizando nuestro menú desde el código de la aplicación Como pasa con todo tipo de recurso que agregamos a nuestros proyectos Android, para utilizarlos en las aplicaciones es necesario convertirlos a objetos programables que podamos manipular. A continuación te comparto el código necesario para utilizar un recurso de Menú en una actividad de la aplicación para desplegar un menú de opciones: @Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.menu, menu); return true; }

El método que utilizamos es onCreateOptionsMenu() que nos permitirá hacer uso de la clase MenuInflater que nos sirve para instanciar un recurso XML de menú dentro de un objeto de la clase Menu; esto se logra llamando al método inflate() que recibe como primer parámetro el recurso XML del menú que será asignado al objeto menú que recibe el método principal onCreateOptionsMenu().

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Cabe mencionar que este método deberás escribirlo fuera del método onCreate() de tu actividad. Y de la misma forma, deberás incluir las siguientes sentencias import para que tu código corra sin problema: import android.view.Menu; import android.view.MenuInflater;

El resultado de correr nuestro demo será el siguiente:

Como mencioné al principio de este post, existen tres tipos de menú que me gustaría abarcar en un post individual con el fin de explicar de forma más detallada las características particulares de cada uno y cómo es que podemos crearlos y manipularlos desde el código.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Fuente: http://androideity.com/2011/09/05/creando-menus-en-android/

SubMenu Un submenú es más que otro menú que aparece al pulsar otra opción de menú. Sólo se puede ir un nivel más profundo, es decir, un submenú no puede tener otro submenú. Para llevar a cabo un submenú, sólo tiene que añadir un elemento del menú como un hijo de un elemento en el menú principal correspondiente. Para demostrarlo, vamos a recortar nuestro menú de opciones por debajo de los artículos trece a cinco, así que no es necesario meterse con el "más" opción. Esto nos da la disposición a continuación.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Para agregar nuestra submenú, se puede editar el código XML directamente o utilizar el diseñador. Al igual que en los ejemplos anteriores, vamos a utilizar el primer diseñador.

Nuestra primera opción del menú tendrá el submenú, por lo que seleccione y haga clic en Agregar first_menu_item ..., que nos da el siguiente diálogo.

Es como si Eclipse leer nuestra mente. Hacemos clic en Aceptar, que nos da el diseño que sigue.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Tenga en cuenta que ahora tenemos un submenú vacío añadido por debajo de nuestro primer elemento del menú. Vamos a ir por delante y un par de elementos de menú para este submenú en la misma forma que habría que añadir elementos de menú al menú principal, lo que resulta en un diseño de la siguiente manera.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Para ver nuestra submenú en la acción, ejecutamos nuestra aplicación, presione el botón de menú, y seleccione la primera opción del menú.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Y ahí está nuestra submenú, con un cabezazo que corresponde a la opción de menú se seleccionaron para mostrar dicho submenú. Aparte de la restricción en el submenú de anidación, los elementos de un submenú puede ser de estilo al igual que sus padres los elementos del menú. Además, el desbordamiento se trata como elementos de menú más allá del quinto punto en el menú principal se manejan, es decir, por el desplazamiento.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Fuente: http://www.barebonescoder.com/2010/08/android-development-submenus/

Creacion de Menu y Submenu

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Menú de Creación y SubMenu en Android En este tutorial, voy a explicar, cómo crear el menú de opciones, etc submenú.

De la clase de actividad, sólo reemplazar el método, onCreateOptionsMenu (). A continuación, dentro del método, crear el menú, de acuerdo con nuestro deseo.

A continuación, sustituir a otro método llamado, onOptionsItemSelected. En esto, si se selecciona ninguna, el menú, lo que tenemos que hacer, será de código de este. Esto significa, eventos de menú se manejan en este método.

public boolean onOptionsItemSelected (elemento MenuItem) { super.onOptionsItemSelected (punto); switch (item.getItemId ()) { caso 0: Toast.makeText (this, "hace clic en el Menú 1", . Toast.LENGTH_SHORT) show (); break; case 1: Toast.makeText (this, "hace clic en el menú 2", . Toast.LENGTH_SHORT) show (); break; case 2: Toast.makeText (this, "hace clic en el menú 3", . Toast.LENGTH_SHORT) show (); break; } return true; }

La captura de pantalla se verá así.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Para añadir submenú, tenemos que usar la función llamada addSubmenu (), en la clase Menu el código es,

onCreateOptionsMenu pública booleano (menú Menú) { super.onCreateOptionsMenu (menú); Sub submenu = menu.addSubMenu (0,1,0 ", submenú"); sub.add (0,11,0 ", submenú 1"); sub.add (0,12,0, "Submenú 2"); sub.add (0,13,0, "submenu 3"); return true; }

La captura de pantalla de esto es así ..

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Cuando haga clic en el submenú, vamos a ver la pantalla como esta ..

Fuente: http://smartandroidians.blogspot.com/2009/11/creating-menu-submenu.html

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Activity la clase Activity, ya que es la que compone las aplicaciones de este OS. Voy a empezar con la actividad HelloAndroid que creamos en la entrada anterior: package com.example.helloandroid; import android.app.Activity; import android.os.Bundle; public class HelloAndroid extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } }

Al crear una clase que extienda de Activity hay que implementar al menos la función onCreate(), que es la que se ejecuta cuando se crea la actividad. Por defecto esa función recibe un paquete (Bundle), que contiene el estado anterior de la actividad en caso de que haya sido suspendida. Como se puede ver arriba, la clase HelloAndroid le pasa ese paquete a la superclase de la que extiende.

Lo siguiente que se hace en la función de creación es cargar el layout o diseño de la actividad, cargando una interfaz definida en XML. Como ya expliqué en otra entrada anterior, los diseños se guardan en “res/layout/”, y para llamarlos se utiliza R, indicando el nombre del fichero, como en este caso, “main.xml” pasa a ser “R.layout.main”.

Si quisiéramos cargar otro layout sólo tendríamos que crearlo y cargarlo con “R.layout.LO_QUE_SEA” Por ahora, de entre las funciones que incluye la actividad he usado:   

onConfigurationChanged(): a la que se llama cuando cambia la configuración, la usé para dejar fija la pantalla y que no rotara (ya explicaré otro día como). getResources(): para obtener los recursos asociados a R. startActivity(): para cambiar de actividad, más abajo explicaré como.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 

 

finish(): para finalizar la actividad, OJO, cuando sea posible, no corta la ejecución en seco, termina de ejecutar. Con esto quiero decir que si debajo de un finish tenemos otras lineas de código, no van a dejar de ejecutarse. getIntent(): devuelve la intención que ha comenzado la actividad. Se utiliza para pasar variables entre actividades, eso irá a otra entrada del blog… getSharedPreferences(): para obtener las preferencias compartidas de la aplicación, que son variables que se almacenan en el móvil y no se borran si no la desinstalas, otra cosa que va a otra entrada.

Ahora para terminar voy a poner un ejemplo de uso de la clase Intent (Intención?), que indica una operación a realizar, como puede ser el cambio entre dos actividades. Para el ejemplo voy a crear otra actividad que se llame GoodbyeAndroid: 

Primero creo una nueva clase Java que extienda de Activity:



A continuación creo un nuevo layout goodbye.xml (esto no lo explico hoy) y lo cargo en la función de creación de la nueva clase, de forma que quede:

package com.example.helloandroid; import android.app.Activity; import android.os.Bundle; public class GoodbyeAndroid extends Activity { @Override public void onCreate(Bundle savedInstanceState) {

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” super.onCreate(savedInstanceState); setContentView(R.layout.goodbye); //El resto del codigo } } 

Ahora añado la nueva actividad al AndroidManifest, ya sea usando la herramienta gráfica o añadiendo directamente al XML debajo de </activity> lo siguiente:

<activity android:name=".GoodbyeAndroid"></activity>

Como se puede ver GoodbyeAndroid.java pasa a ser “.GoodByeAndroid“, y eso ocurre con el resto de actividades. 

Por último añado a la función de creación de HelloAndroid el código con el Intent que cambia entre las dos actividades (para que funcione hay que importar el paquete android.content.Intent):

Intent intent = new Intent(HelloAndroid.this, GoodbyeAndroid.class); startActivity(intent); Fuente: http://www.tecnocaos.com/desarrollo-en-android-iii-la-claseactivity-y-cambio-entre-actividades/

Intent Intenciones y filtros de Intención En este documento 1. Objetos Intent 2. Intención de Resolución 3. Filtros de Intención 4. Los casos más comunes 5. Utilizando la intención coincidente 6. Nota Ejemplo Pad

Clases de clave 1. Intent

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” 2. IntentFilter 3. BroadcastReceiver 4. PackageManager

Tres de los componentes básicos de una aplicación - las actividades, servicios y receptores de radio - se activan a través de mensajes, llamada intenciones. Intención de mensajería es una instalación para finales de tiempo de ejecución de la unión entre los componentes de las mismas o diferentes aplicaciones. La misma intención, una Intent objeto, es una estructura de datos pasiva la celebración de una descripción abstracta de una operación para llevar a cabo - o, a menudo en el caso de las emisiones, una descripción de algo que ha sucedido y anunció que se. Hay mecanismos separados para la entrega de los intentos para cada tipo de componente: 

Un objeto se pasa a la intención Context.startActivity() o Activity.startActivityForResult() para poner en marcha una actividad o conseguir una actividad existente de hacer algo nuevo. (También se puede pasar a Activity.setResult() para devolver información a la actividad que se llama startActivityForResult() .)



Un objeto se pasa a la intención Context.startService() para iniciar un servicio o entregar nuevas instrucciones a un servicio continuo. De manera similar, una intención se puede pasar a Context.bindService() para establecer una conexión entre el componente de llamada y un servicio de destino. Opcionalmente, puede iniciar el servicio si no está ya en ejecución.

Intent objetos pasa a cualquiera de los métodos de difusión (como Context.sendBroadcast() , Context.sendOrderedBroadcast() , o Context.sendStickyBroadcast() ) se entregan a todos los receptores de radiodifusión interesadas. Muchos tipos de emisiones se originan en el código del sistema.



En cada caso, el sistema Android encuentra la actividad apropiada, servicio o conjunto de receptores de radiodifusión para responder a la intención, instanciarlos si es necesario. No hay superposición dentro de estos sistemas de mensajería: los intentos de difusión se entregarán solamente a los receptores de difusión, nunca a las actividades o servicios. Un intento de pasar a startActivity() se entrega sólo a una actividad, nunca a un receptor del servicio o de difusión, y así sucesivamente.

Este documento comienza con una descripción de los objetos Intent. A continuación, se describen las reglas para Android utiliza para asignar las intenciones de los componentes la forma en que se resuelve el componente que debe recibir un mensaje de intención. Para propósitos que no nombran explícitamente un componente de destino, este proceso consiste en comprobar el objeto Intención contra la intención filtros asociados con los objetivos potenciales.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

Objetos Intent Una Intent objeto es un conjunto de información. Contiene información de interés para el componente que recibe la intención (como la adopción de medidas y los datos para actuar en), además de información de interés para el sistema Android (por ejemplo, la categoría de componente que debe manejar la intención y las instrucciones sobre cómo poner en marcha una actividad de destino). Principalmente, se puede contener lo siguiente: Nombre del Componente El nombre del componente que debe manejar el intento. Este campo es un ComponentName objeto - una combinación del nombre de clase completo del componente de destino (por ejemplo, " com.example.project.app.FreneticActivity ") y el nombre del paquete establecido en el archivo de manifiesto de la aplicación en la que reside el componente (por ejemplo, " com.example.project "). La parte del paquete del nombre del componente y el nombre del paquete establecido en el manifiesto no necesariamente tienen que coincidir.

El nombre del componente es opcional. Si se establece, el objeto de Intención se entrega a una instancia de la clase designada. Si no se establece, Android utiliza otro tipo de información en el objeto de la intención de localizar un blanco adecuado ver Resolución intención , más adelante en este documento.

El nombre del componente se ajusta setComponent() , setClass() , o setClassName() y leído por getComponent() .

Acción Una cadena con el nombre de la acción a realizar - o, en el caso de los intentos de difusión, la acción que llevó a cabo y se está informando. La clase de Intención define una serie de constantes acciones, incluyendo los siguientes:

Constante

Objetivo de componentes

Acción

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” ACTION_CALL ACTION_EDIT

actividad actividad

ACTION_MAIN

actividad

ACTION_SYNC

actividad

ACTION_BATTERY_LOW

difusión del receptor ACTION_HEADSET_PLUG difusión del receptor ACTION_SCREEN_ON difusión del receptor ACTION_TIMEZONE_CHANGED difusión del receptor

Iniciar una llamada telefónica.

Visualización de los datos para el usuario que desea editar.

Puesta en marcha como la actividad inicial de una tarea, con la entrada de datos que no y no hay salida de regresar.

Sincronización de datos en un servidor con los datos en el dispositivo móvil.

Una advertencia de que la batería está baja.

Un auricular se ha conectado en el dispositivo, o se desconecta de ella.

La pantalla se ha encendido.

La configuración de la zona horaria ha cambiado.

Ver la Intent descripción de la clase para una lista de constantes predefinidas para acciones genéricas. Otras acciones se definen en otras partes de la API de Android.

Usted también puede definir sus propias cadenas de acción para la activación de los componentes en su aplicación. Los que inventan debe incluir el paquete de aplicaciones como prefijo - por ejemplo: " com.example.project.SHOW_COLOR ".

La acción determina en gran medida de cómo el resto de la intención está estructurada - en particular los datos y extras campos - tanto como un nombre de método determina un conjunto de argumentos y un valor de retorno. Por esta razón, es una buena idea utilizar nombres de las acciones que sean lo más específico posible, y para acoplarlas con fuerza a los otros campos de la intención. En otras palabras, en lugar de definir una acción de forma aislada, definir un protocolo completo de los objetos Intent sus componentes pueden manejar.

La acción en un objeto Intención es fijado por el setAction() método y leído por getAction() .

Datos El URI de los datos para que se actúe sobre y el tipo MIME de los datos. Las diferentes acciones se combinan con diferentes tipos de especificaciones de los datos. Por ejemplo, si el campo de acción es ACTION_EDIT , el campo de datos que contiene el URI del documento que se mostrará para su edición. Si la acción es ACTION_CALL , el campo de datos sería un tel: URI con el número para llamar. Del mismo modo, si la acción es

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” ACTION_VIEW y el campo de datos es un http: URI, la actividad que reciba serían

llamados para descargar y mostrar todos los datos que el URI se refiere.

Cuando se especifique la intención de un componente que es capaz de manejar los datos, a menudo es importante saber el tipo de datos (su tipo MIME), además de su URI. Por ejemplo, un componente capaz de mostrar datos de la imagen no debe ser llamada a desempeñar un archivo de audio.

En muchos casos, el tipo de datos se puede deducir de la URI - sobre todo content: URI, que indican que se encuentran los datos en el dispositivo y controlada por un proveedor de contenido (ver la discusión por separado de los proveedores de contenido ). Sin embargo, el tipo también se puede establecer explícitamente en el objeto de Intención. El setData() método especifica los datos sólo como un URI, setType() que especifica sólo como un tipo MIME, y setDataAndType() que especifica tanto como una URI y un tipo MIME. El URI es leído por getData() y el tipo de getType() .

Categoría Una cadena que contiene información adicional sobre el tipo de componente que debe manejar el intento. Cualquier número de descripciones de la categoría se puede colocar en un objeto Intención. Al igual que para las acciones, la clase de Intención define varias constantes de categoría, incluyendo los siguientes: Constante

Sentido CATEGORY_BROWSABLE La actividad de destino puede ser con seguridad invocada por el navegador para mostrar los datos referenciados por un enlace, por ejemplo, una imagen o un mensaje de correo electrónico.

CATEGORY_GADGET La actividad puede ser embebido dentro de otra actividad que organiza los gadgets.

CATEGORY_HOME La actividad muestra la pantalla de inicio, la primera pantalla que ve el usuario cuando el dispositivo está encendido o cuando el botón de inicio se presiona.

CATEGORY_LAUNCHER La actividad puede ser la actividad inicial de una tarea y se enumeran en el lanzador de aplicaciones de nivel superior.

CATEGORY_PREFERENCE La actividad de destino es un panel de preferencias.

Ver la Intent descripción de la clase para la lista completa de categorías.

El addCategory() método coloca en una categoría de un objeto, la intención removeCategory() elimina una categoría previamente agregado, y

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” getCategories()

obtiene el conjunto de todas las categorías actualmente en el

objeto.

Extras Pares clave-valor para la información adicional que debe ser entregado a la componente de manejo de la intención. Al igual que algunas acciones se combinan con determinados tipos de URIs de datos, algunos están vinculados con los suplementos particulares. Por ejemplo, un ACTION_TIMEZONE_CHANGED la intención tiene un " time-zone "extra que identifica a la nueva zona horaria, y ACTION_HEADSET_PLUG tiene un " state "extra que indica si el auricular ya está conectado o desconectado, así como un" name "extra para el tipo de auriculares. Si se va a inventar un SHOW_COLOR acción, el valor del color se encuentra en un extra par clave-valor.

El objeto de Intención tiene una serie de put...() los métodos para la inserción de diversos tipos de datos adicionales y un conjunto similar de get...() los métodos para leer los datos. Estos métodos son paralelos a los de Bundle objetos. De hecho, los extras se puede instalar y leer como un paquete mediante el putExtras() y getExtras() métodos.

Banderas Banderas de distintos tipos. Muchos instruyen al sistema Android de cómo iniciar una actividad (por ejemplo, que la tarea de la actividad debe pertenecer a) y cómo tratarla después de que se puso en marcha (por ejemplo, si pertenece a la lista de las actividades recientes). Todos estos indicadores se definen en la clase de intenciones.

El sistema Android y las aplicaciones que vienen con la plataforma de utilizar objetos Intent tanto para enviar por el sistema se originaron las emisiones y para activar los componentes definidos por el sistema. Para ver la forma de estructurar la intención de activar un componente del sistema, consulte la lista de las intenciones de la referencia.

Intención de Resolución Intentos se puede dividir en dos grupos: 

Las intenciones explícitas de designar el componente de destino por su nombre (el campo de nombre del componente , mencionado anteriormente, tiene un conjunto de valores).

Dado que los nombres de los componentes que generalmente no se conoce a los desarrolladores de otras aplicaciones, las intenciones explícitas se utilizan normalmente

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” para la aplicación de mensajes internos - como una actividad de inicio de un servicio subordinado o el lanzamiento de una actividad hermana. 

Intenciones implícitas no nombrar a un objetivo (el campo para el nombre del componente está en blanco). Intentos implícitos se utilizan a menudo para activar componentes en otras aplicaciones.

Android ofrece una intención explícita de una instancia de la clase de destino designado.

Nada de lo dispuesto en el objeto que no sea la intención de los asuntos de los componentes de nombres para determinar qué componentes deben tener la intención.

Una estrategia diferente es necesario para las intenciones implícitas. En ausencia de un objetivo designado, el sistema Android tiene que encontrar el mejor componente (o componentes) para manejar la intención - una sola actividad o servicio para realizar la acción requerida, o la serie de los receptores de radiodifusión para responder a la convocatoria de difusión. Lo hace comparando el contenido del objeto intención de filtros intención, estructuras asociadas con los componentes que potencialmente pueden recibir intentos. Filtros de publicidad de las capacidades de un componente y delimitar las intenciones que puede manejar. Abren el componente de la posibilidad de recibir las intenciones implícitas del tipo anunciado. Si un componente no tiene la intención de los filtros, puede recibir sólo las intenciones explícitas. Uno de los componentes con los filtros pueden recibir ambos intentos explícitos e implícitos.

Sólo tres de los aspectos de un objeto Intención son consultados cuando el objeto se compara con un filtro de intención: acción los datos (tanto tipo de URI y datos) categoría Los suplementos y las banderas no desempeñan ningún papel en la resolución el componente que recibe una intención.

Filtros de Intención

Para informar al sistema que las intenciones implícitas que pueden manejar, actividades, servicios y receptores de radiodifusión puede tener uno o más filtros de intención. Cada filtro se describe una capacidad del componente, un conjunto de intentos que el componente está dispuesto a recibir. Es, en efecto, los filtros en las intenciones de un tipo deseado, filtrando los intentos no deseados-, pero las intenciones implícitas sólo no deseados (los que no nombra una clase de destino). Un intento explícito se entrega siempre a su objetivo, no importa lo que contiene, el filtro no es consultado. Pero una intención

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” implícita es entregado a un componente sólo si puede pasar a través de uno de los filtros del componente.

Un componente dispone de filtros independientes para cada puesto de trabajo que puede hacer, cada cara se puede presentar al usuario. Por ejemplo, la actividad NoteEditor de la aplicación de ejemplo de Notas tiene dos filtros, uno para la puesta en marcha con una nota específica que el usuario puede ver o editar, y otro para comenzar con una nueva nota en blanco que el usuario puede rellenar y guardar . (Todos los filtros Pad Nota se describen en la Nota Ejemplo almohadilla sección, más adelante.)

Los filtros y de seguridad Un filtro de intención no puede ser invocado por la seguridad. Si bien se abre un componente de recibir sólo cierto tipo de intenciones implícitas, no hace nada para prevenir los intentos explícitos de la focalización del componente. A pesar de que un filtro restringe las intenciones se pidió un componente para manejar a ciertas acciones y fuentes de datos, siempre hay alguien que podía armar una intención explícita, con una acción diferente y una fuente de datos, y el nombre del componente como el objetivo.

Un filtro de intención es una instancia de la IntentFilter clase. Sin embargo, dado que el sistema Android tiene que saber acerca de las capacidades de un componente antes de que pueda poner en marcha este componente, los filtros de la intención general no se estableció en el código de Java, pero en el archivo de manifiesto de la aplicación (AndroidManifest.xml) como <intent-filter> elementos . (La única excepción sería filtros para receptores de radiodifusión que se registran dinámicamente llamando Context.registerReceiver() , sino que están creados directamente como objetos IntentFilter.)

Un filtro tiene campos paralelos a la acción, los datos y los campos de la categoría de un objeto Intención. La intención implícita se compara con el filtro en las tres áreas. Para ser entregado al componente que posee el filtro, debe pasar las tres pruebas. Si falla uno solo de ellos, el sistema Android no lo entregará al componente - al menos no sobre la base de ese filtro. Sin embargo, puesto que un componente puede tener varios filtros de intención, la intención de que no pasa por uno de los filtros de un componente puede hacerlo a través de otro.

Cada una de las tres pruebas se describe en detalle a continuación: Acción de la prueba

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Un <intent-filter> elemento en el archivo de manifiesto enumera las acciones que <action> subelementos. Por ejemplo: <Intención de filtro. . . > <accion android:name="com.example.project.SHOW_CURRENT" /> <accion android:name="com.example.project.SHOW_RECENT" /> <accion android:name="com.example.project.SHOW_PENDING" /> . . . </ Intención de filtro>

Como muestra el ejemplo, mientras que un objeto Intención nombres simplemente una sola acción, un filtro puede mostrar más de uno. La lista no puede estar vacío, un filtro debe contener al menos un <action> elemento, o que bloqueará todos los intentos.

Para pasar esta prueba, la acción especificada en el objeto de Intención debe coincidir con una de las acciones enumeradas en el filtro. Si el objeto o el filtro no especifica una acción, los resultados son como sigue: 

Si el filtro falla a la lista de las acciones, no hay nada que la intención de hacer coincidir, por lo que todos los intentos fallan la prueba. No hay intenciones puede conseguir a través del filtro.



Por otro lado, un objeto Intención que no especifica una acción automáticamente pasa la prueba - siempre y cuando el filtro contiene al menos una acción.

Categoría de prueba Un <intent-filter> elemento también se enumeran las categorías como subelementos. Por ejemplo: <Intención de filtro. . . > <category android:name="android.intent.category.DEFAULT" /> <category android:name="android.intent.category.BROWSABLE" /> . . . </ Intención de filtro>

Tenga en cuenta que las constantes descritas anteriormente para las acciones y las categorías no se utilizan en el archivo de manifiesto. Los valores de la cadena completa se utilizan en su lugar. Por ejemplo, el " android.intent.category.BROWSABLE "cadena en el ejemplo anterior corresponde a la CATEGORY_BROWSABLE constante mencionado anteriormente en este documento. Del mismo modo, la cadena " android.intent.action.EDIT "corresponde a la ACTION_EDIT constante.

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” Para un intento de pasar la prueba de categoría, todas las categorías en el objeto de Intención debe coincidir con una categoría en el filtro. El filtro puede incluir categorías adicionales, pero no se puede omitir cualquiera que esté en el intento.

En principio, por lo tanto, un objeto Intención con ninguna categoría siempre debe pasar esta prueba, independientemente de lo que está en el filtro. Eso es todo cierto.

Sin embargo, con una excepción, Android trata todas las intenciones implícitas pasan a startActivity() como si contuvieran al menos una categoría: " android.intent.category.DEFAULT "(el CATEGORY_DEFAULT constante). Por lo tanto, las actividades que están dispuestos a recibir las intenciones implícitas debe incluir " android.intent.category.DEFAULT "en los filtros de sus intenciones.

(Filtros con " android.intent.action.MAIN "y" android.intent.category.LAUNCHER ajustes "son la excepción. Ellos marcan las actividades que se inician nuevas tareas y que están representados en la pantalla de inicio. Pueden incluir" android.intent.category.DEFAULT "en la lista de categorías, pero no es necesario.) Véase el uso de coincidencia de intenciones , más tarde, para más información sobre estos filtros.)

Los datos de prueba Al igual que la acción y categorías, la especificación de datos para un filtro intención está contenida en un subelemento. Y, como en esos casos, el subelemento puede aparecer varias veces, o nada en absoluto. Por ejemplo: <Intención de filtro. . . > <Datos de Android: mimeType = "video / mpeg" android: scheme = "http". . . /> <Datos de Android: mimeType = "audio / mpeg" android: scheme = "http". . . /> . . . </ Intención de filtro>

Cada <data> elemento puede especificar un URI y un tipo de datos (tipo de contenido MIME). Hay atributos separados, scheme , host , port , y la path - para cada parte de la URI: scheme://host:port/path

Por ejemplo, en la siguiente URI, content://com.example.project:200/folder/subfolder/etc

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” el esquema es " content ", el anfitrión es" com.example.project ", el puerto es" 200 ", y el camino es" folder/subfolder/etc ". El host y el puerto en conjunto constituyen la autoridad URI, si un host no se especifica, el puerto se ignora.

Cada uno de estos atributos es opcional, pero no son independientes entre sí: para que una autoridad que tenga sentido, un sistema también debe ser especificado. Por un camino que tenga sentido, tanto en el régimen y la autoridad debe ser especificado.

Cuando el URI en un objeto Intención se compara con una especificación URI en un filtro, se compararon sólo a las partes de la URI realmente mencionadas en el filtro.

Por ejemplo, si un filtro especifica sólo un esquema, todos los URI con dicho régimen coincide con el filtro. Si un filtro especifica un esquema y una autoridad, pero no hay camino, todos los URI con el mismo esquema y el partido de la autoridad, independientemente de sus caminos. Si un filtro especifica un esquema, una autoridad, y un camino, sólo URI con el mismo esquema, la autoridad, y el partido camino. Sin embargo, una especificación de ruta en el filtro puede contener comodines para requerir sólo una coincidencia parcial de la ruta.

El type atributo de un <data> elemento especifica el tipo MIME de los datos. Es más común en los filtros que un URI. Tanto el objeto de Intención y el filtro se puede utilizar un comodín "*" para el campo de subtipo - por ejemplo, " text/* "o" audio/* "- indica los partidos subtipo.

La prueba de los datos compara el URI y el tipo de datos en el objeto de Intención para un tipo de URI y los datos especificados en el filtro. Las reglas son como sigue: a. Un objeto Intención que no contiene ni un URI, ni un tipo de datos pasa la prueba si el filtro del mismo modo no se especifica ningún tipo URI o de datos.

b. Un objeto Intención que contiene un URI, pero ningún tipo de datos (y un tipo que no se puede deducir de la URI) pasa la prueba si su URI coincide con una URI en el filtro y el filtro del mismo modo no se especifique el tipo.

Este será el caso sólo para los URIs como mailto: y el tel: que no se refieren a los datos reales. c. Un objeto Intención que contiene un tipo de datos pero no es un URI pasa la prueba si el filtro muestra el mismo tipo de datos y de manera similar no especifica un URI. d. Un objeto Intención que contiene un URI y un tipo de datos (o un tipo de datos se puede deducir de la URI) pasa a la parte de tipo de datos de la prueba sólo si su tipo concuerda con un tipo que figuran en el filtro. Pasa a la parte URI de la prueba, ya sea si su URI coincide con una URI en el filtro

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” o si tiene un content: o file: URI y el filtro no se especifica un URI. En otras palabras, un componente se presume que apoyar content: y file: datos si sus listas de filtros sólo un tipo de datos.

Si la intención puede pasar a través de los filtros de más de una actividad o servicio, el usuario puede pedir el componente para activar. Se produce una excepción si no se meta se puede encontrar.

Los casos más comunes

La última regla de arriba para la prueba de los datos, la regla (d), refleja la expectativa de que los componentes son capaces de obtener datos locales de un archivo o un proveedor de contenido. Por lo tanto, los filtros se pueden enumerar sólo un tipo de datos y no es necesario mencionar explícitamente el content: y el file: esquemas. Este es un caso típico. Un <data> elemento como el siguiente, por ejemplo, dice que el componente de Android puede obtener datos de la imagen de un proveedor de contenido y mostrarlo: datos> android:mimeType="image/*" />

Como la mayoría de los datos disponibles se distribuye los proveedores de contenido, filtros que especifican un tipo de datos, pero no un URI son, quizás, el más común.

Otra configuración común son los filtros con un esquema y un tipo de datos. Por ejemplo, un <data> elemento como el siguiente Android dice que el componente puede obtener los datos de vídeo de la red y mostrar que: datos> android:scheme="http" android:type="video/*" />

Consideremos, por ejemplo, lo que hace la aplicación del navegador cuando el usuario sigue un enlace en una página web. En primer lugar, trata de mostrar los datos (como podría si el enlace era una página HTML). Si no puede visualizar los datos, que reúne una intención implícita con el tipo de sistema y de datos y trata de iniciar una actividad que puede hacer el trabajo. Si no hay compradores, se pregunta el gestor de descargas para descargar los datos. Esto se pone bajo el control de un proveedor de contenido, por lo que una piscina potencialmente más amplio de actividades (aquellos con filtros que sólo nombrar un tipo de datos) puede responder.

La mayoría de las aplicaciones también tienen una forma de empezar de cero, sin referencia a ningún dato en particular. Actividades que pueden iniciar las aplicaciones tienen filtros con " android.intent.action.MAIN "definida como la acción. Si van a estar representados en el lanzador de aplicaciones, que también se especifica el " android.intent.category.LAUNCHER "la categoría:

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana” <Intención de filtro. . . > <accion android:name="code android.intent.action.MAIN" /> <category android:name="code android.intent.category.LAUNCHER" /> </ Intención de filtro>

Utilizando la intención coincidente

Intenciones se comparan con filtros de la intención no sólo de descubrir un componente de destino para activar, pero también para descubrir algo sobre el conjunto de componentes en el dispositivo. Por ejemplo, el sistema Android rellena el lanzador de aplicaciones, la pantalla de nivel superior que muestra las aplicaciones que están disponibles para el usuario para poner en marcha, mediante la búsqueda de todas las actividades de los filtros con la intención que se especifica el " android.intent.action.MAIN "acción y " android.intent.category.LAUNCHER "categoría (como se ilustra en la sección anterior).

A continuación, muestra los iconos y las etiquetas de esas actividades en el lanzador. Del mismo modo, se descubre la pantalla de inicio mediante la búsqueda de la actividad con " android.intent.category.HOME "en su filtro.

La aplicación puede utilizar coincidencia de intención es una manera similar. El PackageManager tiene un conjunto de query...() los métodos que devuelven todos los componentes que pueden aceptar una intención particular, y una serie similar de resolve...() métodos que determinan el mejor componente para responder a una intención. Por ejemplo, queryIntentActivities() devuelve una lista de todas las actividades que pueden llevar a cabo la intención de pasar como argumento, y queryIntentServices() devuelve una lista similar de servicios. Ninguno de estos métodos se activan los componentes, sino que simplemente una lista de los que pueden responder. No hay un método similar, queryBroadcastReceivers() , para los receptores de radiodifusión.

Fuente: http://developer.android.com/guide/topics/intents/intents-filters.html Videos: http://www.google.com.mx/url?sa=t&rct=j&q=&esrc=s&source=web&cd=8&cts=1331344 473510&ved=0CHIQtwIwBw&url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dl qopIf-bA54&ei=bLNaT5n5Lojq2QW0_-j_DA&usg=AFQjCNFQSaRAM7yqxWCOlqCL58uzEFsFw&sig2=7tACmsU1CMDdHwYGlTHdig

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO

Investigación de Android Autor: Héctor Campos Alonso “Estudia hoy, se mejor mañana”

UNIVERSIDAD TECNOLÓGICA DE TECAMACHALCO