Conceptos básicos de entorno, estructura componentes y desarrollo.

Conceptos básicos de entorno, estructura componentes y desarrollo.

Interfaces de usuario (View, Layouts)

La interfaz de usuario se define en los archivos XML del directorio res/layout. Cada pantalla tendrá un código XML diferente.

   Diseñar una pantalla usando Java puede resultar complejo y poco eficiente, sin embargo, Android soporta XML para diseñar pantallas y define elementos personalizados, cada uno representando a un "subclase" especifica de view. Se pueden crear pantallas de la misma manera que se diseñan ficheros HTML.

    Cada fichero describe un layout(una pantalla) y cada layout a su vez puede contener otros elementos. Para gestionar la interfaz de usuario, Android introduce las siguientes terminologías:

 * View:  Una view es un objeto cuya clase es android.view.View. Es una estructura de datos cuyas propiedades contienen los datos de la capa, la información específica del área rectangular de la pantalla y permite establecer el layout. Una view tiene: layout, drawing, focus change, scrolling, etc..

   La clase view es útil como clase base para los widgets, que son unas subclases ya implementadas que dibujan los elementos en la pantalla. Los widgets contienen sus propias medidas, pero puedes usarlas para construir tu interfaz más rápidamente. La lista de widgets que puedes utilizar incluyen Text, EditText, InputMethod, MovementMethod, Button, RadioButton, CheckBox, y ScrollView.

 * Viewgroups: Un viewgroup es un objeto de la clase android.view.Viewgroup, como su propio nombre indica, un viewgroup es un objeto especial de view cuya function es contener y controlar la lista de views y de otros viewgroups. Los viewgroups te permiten añadir estructuras a la interfaz y acumular complejos elementos en la pantalla que son diseccionados por una sola entidad.

La clase viewgroup es útil como base de la clase layouts, que son subclases implementadas que proveen los tipos más comunes de los layouts de pantalla. Los layouts proporcionan una manera de construir una estructura para una lista de views.

 * Árbol estructurado de la interfaz UI:  En la plataforma Android tú defines una Activity del UI usando un árbol de nodos view y viewgroups, como vemos en la imágen de abajo. El árbol puede ser tan simple o complejo como necesites hacerlo, y se puede desarrollar usando los widgets y layouts que Android proporciona o creando tus propios views.

   Los views y viewgroups deben estar contenidos en los layouts, los cuales contienen otros elementos presentes en una vista. Dentro de cada layout podemos poner todos los elementos necesarios, incluidos otros layouts. Así conseguiremos estructurar la pantalla de la manera deseada. Existen una gran variedad de layouts, en función de su posicionamiento en la pantalla y se describen a continuación algunos de ellos:

 * LinearLayout: Se les conoce como contenedores y sirven para reorganizar los elementos de nuestra aplicación. Sus hijos son los views, viewgroup u otros layouts. Nos permitirán alinear sus hijos en una única dirección, ya sea horizontal o vertical como se muestra en las siguientes imagenes. La orientación predeterminada es horizontal.

 

 

                     

 

 

 * RelativeLayout: En este caso todos los elementos van colocados en una posición relativa a otro. Aquí podemos jugar con las distancias entre elementos en la pantalla, la cual se expresa en pixeles. A continuación se muestra un ejemplo:

                                           

 

 

 * Absolute layout: Coloca los elementos en posiciones absolutas en la pantalla, teniendo en cuenta que la posición (0,0) es el extremo superior izquierdo de la pantalla. A continuación se puede ver un ejemplo para entender mejor la explicación anterior.El absolute layout especifica la ubicación exacta de sus hijos.

                                                                

 

 

 * TableLayout: permite colocar los elementos en forma de tabla. Se utiliza el elemento <TableRow> para designar a una fila de la tabla. Cada fila puede tener uno o más puntos de vista. Cada vista se coloca dentro de una fila en forma de celda.  

 

 * FrameLayout: Es un marcador de posición que puede usarse para mostrar una única vista. Se pueden agregar multiples puntos de vista a un FrameLayout pero cada uno se acumulará en la parte superior izquierda de la anterior. A continuación mostramos un ejemplo ilustrativo: 

 

 

 

 

  * ScrollView: Es un tipo especial de FrameLayout ya que permite a los usuarios desplazarse por una serie de puntos de vista que ocupan más espacio que el despliegue físico. El scrollView solo puede contener un viewGroup y suele ser LinearLayout.

Cómo crear una etiqueta en Email de Android

          Cómo crear una etiqueta en Email de Android

Añade etiquetas a tu cuenta de Gmail y estas serán automáticamente añadidas a tu Email de Android.

Sean Gallup/Getty Images News/Getty Images

Cualquier celular que ejecute el sistema operativo móvil Android requiere que su usuario se registre a una cuenta de Google y utilice Gmail como su gestor predeterminado de correo electrónico. En lugar de carpetas, Gmail deja que sus usuarios ordenen sus correos electrónicos con etiquetas. Ya que tu cuenta de Gmail se sincroniza con tu dispositivo Android, cualquier etiqueta que crees mediante Gmail será añadida a la aplicación Email en tu dispositivo Android. Esto significa que puedes crear etiquetas para Email de Android desde tu navegador web.

Instrucciones

1. Abre tu navegador y explora hasta Gmail.com. Ingresa tus datos de inició de tu cuenta de Google en los campos correspondientes y haz clic en el botón "Iniciar sesión" para acceder a tu cuenta.
2. Haz clic en el icono de "engranaje" en la esquina superior derecha de tu página inicial de Gmail y selecciona la opción "Configuraciones de correo" desde el menú desplegable.
3. Haz clic en la pestaña "Etiquetas" y luego en el botón "Crear nueva etiqueta".
4. Ingresa el nombre de la nueva etiqueta en el espacio ofrecido. Si quieres convertir la etiqueta en una etiqueta secundaria, haz clic en la flecha bajo el encabezado "Agrupar etiqueta bajo:" y selecciona la etiqueta contenedora desde el menú desplegable.
5. Haz clic en el botón "Crear" para crear una etiqueta. Esta será añadida a la aplicación Email de tu dispositivo Android.

Junto con los botones y las etiquetas, las cajas de texto son el tercer tipo de elemento más común con el que trabajarás. En Android, la clase que utilizamos para implementar las cajas de texto se llama EditText, que es una subclase de TextView que utilizamos para crear etiquetas (labels).

Aparte de las propiedades que esta clase hereda de TextView, posee otras muy interesantes que podemos utilizar:

android:autoText para definir si la caja de texto proveerá corrección ortográfica de manera automática.

android:capitalize si queremos que la caja de texto cambie la primera letra del texto introducido a mayúscula.

android:singleLine para controlar si el texto que se introduzca en la caja de texto ocupará una línea o varias; esta propiedad también define el comportamiento de la tecla Enter (si nos posicionará en el siguiente widget en caso de que su valor sea true o si nos agregará una línea nueva para escribir en caso de que se defina como false).

android:numeric cuando queramos que el texto introducido sean únicamente números.

android:password cuando requerimos que el usuario ingrese datos de tipo contraseña y muestre la información en formato de puntos.

Esta clase posee muchos atributos interesantes que puedes consultar en la tabla XML Attributes de la documentación oficial de Android Developers.

El código…

Para ver el resultado de utilizar algunos de los atributos mencionados arriba vamos a hacer un ejemplo en el que definiremos varios EditText definidos con combinaciones diferentes de atributos para ver su comportamiento en tiempo de ejecución.

1. Creamos un proyecto llamado AndroideityEditText con la versión Android 2.1 update 1.

2. Modificamos el archivo main.xml del directorio res/layout definiendo tres TextView para identificar el atributo que implementa el EditText que colocaremos junto. Así deberá quedarte el código: 

3. Lo ejecutamos y vemos el resultado:

En el primer EditText cada vez que demos Enter nos agregará una línea nueva para seguir escribiendo lo que queramos. En el segundo, utilizamos la propiedad de entrada de texto restringida a números, por lo que aunque tecleemos letras, el resultado en pantalla serán dígitos numéricos. Y por último, utilizamos el atributo de contraseña que como puedes ver hace el texto ilegible para el ojo humano.

Crear ListView Básico en Android

En esta pantalla elegimos el nombre de la Actividad, lo que nos creará también el nombre del layout de la actividad nueva.

Con esto ya tendremos nuestra Activity creada. Ahora nos iremos al XML y añadiremos elListView de esta manera, quedando el xml así:

1 2 3 4 5 6 7 8 9 10 11 12

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"     xmlns:tools="http://schemas.android.com/tools"     android:layout_width="match_parent"     android:layout_height="match_parent"     tools:context=".EjemploListView" >     <ListView         android:id="@+id/listview"         android:layout_width="wrap_content"         android:layout_height="wrap_content"/> </RelativeLayout>

Con esto, si vamos a la parte gráfica del xml podremos ver ya algo así:

A continuación nos dirigimos a nuestro archivo java, ubicado en src/nombre_paquete/EjemploListView.java (en mi caso). Vamos a comenzar declarando elListView y un array de String con unos elementos ya predefinidos, que serán los que usaremos para rellenar el ListView.

1 2 3 4 5 6

public class EjemploListView extends Activity {     private ListView list;     private String[] sistemas = {"Ubuntu", "Android", "iOS", "Windows", "Mac OSX",                                 "Google Chrome OS", "Debian", "Mandriva", "Solaris", "Unix"};

Ahora nos meteremos dentro del método onCreate, para poder inicializar la lista, crear unAdapter, que es una clase la cual usaremos para rellenar el ListView y agregaremos alguna funcionalidad más al ListView.

Para “enlazar” el ListView del xml con la variable de instancia que hemos creado, haremos lo siguiente:

1 2	list = (ListView)findViewById(R.id.listview);

Como vemos, usamos el método findViewById para buscar el id que le dimos al ListView en el xml.

A continuación, vamos a declarar el Adapter. Esta clase será la encargada de adaptar el Array que tenemos a un ListView. En este caso, el adapter será solo de ya que nuestro array solo contiene elementos de tipo String.

1 2	ArrayAdapter<String> adaptador = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, sistemas);

Vamos a analizar bien el ArrayAdapter. Como bien indica el nombre de la clase, es un adaptador de arrays, y en este caso de tipo String.

En su constructor, pasamos como argumentos los siguientes elementos:

Context: Pasamos el Context de la aplicación, mediante el uso de this.

android.R.layout.simple_list_item_1: Esto es el tipo de ListView, en nuestro caso, solo muestra un elemento, por lo tanto usaremos para cada dato un contenedor con un solo elemento.

sistemas: Le pasamos el array con los SO que hemos declarado como variable de instancia que está ubicado debajo del nombre de la clase.

Por último estableceremos el objeto adapter de la clase ArrayAdapter al ListView que hemos declarado, lo que hará que cargue los datos en el y ya podamos verlo en funcionamiento.

1 2	list.setAdapter(adaptador);

Como vemos es un proceso simple, en una sola línea.

Por último, vamos a agregar un listener a la lista, en este caso un onItemClickListener, que producirá un aviso mediante un objeto Toast con el número del elemento pulsado cuando pulsemos sobre la ListView. Esto podemos hacerlo de la siguiente manera.

1 2 3 4 5 6 7 8 9 10 11

list.setOnItemClickListener(new OnItemClickListener(){     @Override     public void onItemClick(AdapterView<?> arg0, View arg1, int position, long id) {         // TODO Auto-generated method stub         Toast.makeText(getApplicationContext(), "Ha pulsado el item " + position, Toast.LENGTH_SHORT).show();     } });

En el método generado, se pasan una serie de parámetros (esto se origina solo si usamos Eclipse). En este caso el que mas nos importa es el parámetro cuyo tipo de dato es int, al cual le he cambiado el nombre para que veamos bien a que se refiere.

A continuación, creamos un Toast, el cual mostrará un aviso que nos devolverá el elemento que hemos pulsado.

Una vez hecho todo esto, podemos lanzar nuestra aplicación, y ver como ha quedado todo, a continuación pongo unas imágenes de como me ha quedado a mí y un pequeño video para verlo en acción:

CONVERSIÓN DE TIPOS DE DATOS EN JAVA

CONVERSIÓN DE TIPOS DE DATOS EN JAVA

CONVERSIÓN DE TIPOS DE DATOS EN JAVA

En Java es posible transformar el tipo de una variable u objeto en otro diferente al original con el que fue declarado. Este proceso se denomina "conversión", "moldeado" o "tipado" y es algo que debemos manejar con cuidado pues un mal uso de la conversión de tipos es frecuente que dé lugar a errores.

Una forma de realizar conversiones consiste en colocar el tipo destino entre paréntesis, a la izquierda del valor que queremos convertir de la forma siguiente: Tipo VariableNueva = (NuevoTipo) VariableAntigua;

Por ejemplo: int miNumero = (int) ObjetoInteger;      char c = (char)System.in.read();

En el primer ejemplo, extraemos como tipo primitivo int el valor entero contenido en un campo del objeto Integer. En el segundo caso, la función read devuelve un valor int, que se convierte en un char debido a la conversión (char), y el valor resultante se almacena en la variable de tipo carácter c.

El tamaño de los tipos que queremos convertir es muy importante. No todos los tipos se convertirán de forma segura. Por ejemplo, al convertir un long en un int, el compilador corta los 32 bits superiores del long (de 64 bits), de forma que encajen en los 32 bits del int, con lo que si contienen información útil, ésta se perderá. Este tipo de conversiones que suponen pérdida de información se denominan “conversiones no seguras” y en general se tratan de evitar, aunque de forma controlada pueden usarse puntualmente.

De forma general trataremos de atenernos a la norma de que "en las conversiones debe evitarse la pérdida de información". En la siguiente tabla vemos conversiones que son seguras por no suponer pérdida de información.

TIPO ORIGEN	TIPO DESTINO
byte	double, float, long, int, char, short
short	double, float, long, int
char	double, float, long, int
int	double, float, long
long	double, float
float	Double

No todos los tipos se pueden convertir de esta manera. Como alternativa, existen otras formas para realizar conversiones.

MÉTODO VALUEOF PARA CONVERSIÓN DE TIPOS

El método valueOf es un método sobrecargado aplicable a numerosas clases de Java y que permite realizar conversiones de tipos. Veamos algunos ejemplos de uso.

EXPRESIÓN	INTERPRETACIÓN aprenderaprogramar.com
miInteger = miInteger.valueOf (i)	Con i entero primitivo que se transforma en Integer
miInteger = miInteger.valueOf (miString)	El valor del String se transforma en Integer
miString = miString.valueOf (miBooleano)	El booleano se transforma en String “true” o “false”
miString = miString.valueOf (miChar)	El carácter (char) se transforma en String
miString = miString.valueOf (miDouble)	El double se transforma en String. Igualmente aplicable a float, int, long.

int/double a String

Para transformar un dato "int" en una cadena de caracteres y poder tratarlo como tal "String"
Ejemplo:

/*

   * Convertir int/double a String

   */

  double dou = 25.23;

  int numer = 300;

  String cad1 = String.valueOf(numer);

  String cad2 = String.valueOf(dou);

  JOptionPane.showMessageDialog(null, "Se convirtio correctamente: "+cad1+" ,"+cad2);

String a double

Se realiza de la siguiente manera:

/*

   * Convertir String a double

   */

  String nume = "100.36";

  double n = Double.parseDouble(nume);

  JOptionPane.showMessageDialog(null, "Se convirtio correctamente: "+n);

1.- Convertir de Integer a String.- En teoría, un número se puede representar como una cadena de caracteres sin realizar ninguna operación; pero la realidad en JAVA es que si asignamos un dato Integer a una cadena de caracteres, el programa que utilicemos (en mi caso NetBeans) les dará un error de incompatibilidad de tipos. Para realizar aquella asignación, se debe realizar lo siguiente, aplicado a un simple ejemplo.

int a=1;
String b=””;
//En la siguiente línea, realizamos la conversión y asignación del resultado.
b=String.valueOf(a);
//En la siguiente línea imprimimos la cadena almacenada, en consola.
System.out.print(b);

2.- Convertir datos Double a String.-En el caso de una conversión de una dato double a String, los pasos son los mismos, aplicados el método valueOf() de la clase String.

double a=1.77;
String b=””;
//En la siguiente línea, realizamos la conversión y asignación del resultado.
b=String.valueOf(a);
//En la siguiente línea imprimimos la cadena almacenada, en consola.
System.out.print(b);

3.- Convertir un dato String a Integer.- Convertir un String a Integer no es tan sencillo como su opuesto, pues, el caso anterior, tenemos que las cadenas de caracteres aceptan cualquier dato, sea este numérico o especial. En cambio, en el caso de los Integer y los Dobule, solamente aceptan números.

Para esto, vamos a contemplar tres casos, el primero el más sencillo, el segundo un poco más complejo, y el tercero imposible de realizar.

Caso 1. Espacios en blanco al principio o al final de los números.- Se siguen los siguientes pasos ordenados:

int a;
String b=” 222 “;
a=Integer.parseInt(b.trim());
System.out.print(a);

El método parseInt() convierte la cadena en entero; pero como vemos, luego de la variable String llamamos al método trim() que lo que realiza es quitar los espacios en blanco iniciales y finales.

Caso 2. Espacios en blanco entre los números.- Se siguen los siguientes pasos ordenados:

int a;
String b=” 2 2 2 “;
a=Integer.parseInt(b.replaceAll(” “, “”));
System.out.print(a);

Hay que tener en cuenta que para cualquier espacio en blanco, se puede usar el caso dos.

4.- Convertir un dato String a Double.- Este caso es parecido a los enteros, por lo que vamos a resumir la aplicación a un solo método, que se trata del segundo de los datos del tipo entero.

int a;
String b=” 2 2 2 . 4 5 “;
a=Double.parseDouble(b.replaceAll(” “, “”));
System.out.print(a);

Estructura de un proyecto android

Estructura de un proyecto android

De forma un poco más detallada cual es la estructura de un proyecto.

La carpeta src

Esta es por defecto la carpeta donde se depositará el código fuente Java, y como en los proyectos para escritorio puede llamarse de otro modo si nos interesa o podemos disponer de distintas carpetas fuente, a veces puede ser un modo de enlazar con librerías.

Todo el código que pongamos en las carpetas fuente será compilado cuando se requiera. Y también como en los proyectos tradicionales de java el código se organizará en carpetas que resultaran en paquetes. Recordad que durante el proceso de creación del proyecto definimos el paquete que lo identificará. Por norma general la estructura de nuestros proyectos partirá de esta raíz tal como se ve en la imagen.

La carpeta res

Esa es una carpeta más compleja ya que se subdivide en múltiples subdirectorios, pero para resumir, diremos que va a contener lo que en el mundo de Android llamaremos recursos. Ya veremos que existen distintos tipos de recursos como imágenes, textos, layouts, y que podemos administrar aquí como se van gestionar los recursos para dispositivos con características y configuraciones distintas (densidad de píxel, localización, etc.…)

La carpeta /res contiene la mayoría de los recursos (ficheros multimedia, diseños de pantalla, cadenas, etc.) que se utilizan en un proyecto Android. 

En el siguiente gráfico puedes observar una estructura de recursos.

Ø  Drawable: Imágenes (PNG, JPEG o GIF) de la aplicación. Puede contener, ente otras, las carpetas /drawable-ldpi, /drawable-mdpi, /drawable-hdpi /drawable-xhdpi para utilizar distintas imágenes en función de la densidad del dispositivo.

Ø  Layout: Ficheros XML que construyen las interfaces de usuario .

Ø  Menú: Ficheros XML con los menús.

Ø  Values: Ficheros XML con valores de cadenas de texto (strings), colores o estilos. También pueden existir carpetas que se denominen values-vmás un número de API para que la aplicación utilice distintos recursos en función de la versión del sistema operativo del dispositivo donde se ejecute.

Ø  Xml: Otros ficheros XML que se usen en la aplicación.

Ø  Raw: Otros ficheros de recursos, como alternativa al almacenamiento en la carpeta assets.

Ø  Anim: Ficheros XML con descripción de animaciones.

Por cada archivo almacenado en la carpeta /res, se genera automáticamente una entrada en el fichero R.java que se encuentra en la carpeta /gen.

Cada entrada en el fichero R.java es un identificador de un recurso al que se puede acceder desde el código Java de la aplicación.

El fichero R.java facilita el acceso a los recursos de la carpeta /res desde el código de la aplicación. 

Si te fijas en un proyecto, observará que hay una vista llamada activity_main.xml que reside en /res/layout, este recurso se ha generado de forma automática al crear un nuevo proyecto.

La compilación del proyecto implica la creación y actualización del fichero R.java(residente en la carpeta /gen) que contiene un método y un identificador para cada recurso.

Para acceder al recurso de las vistas que se encuentra en /res/layout y que se denomina activity_main.xml se utiliza el identificador correspondiente que se ha generado en R.java.
Así, en la actividad principal, para cargar la vista tendría que introducir la siguiente orden:

Donde R.layout.activity_main sería la forma de identificar al fichero/res/layout/activity_main.xml.

Nota: Fíjese en la construcción del identificador del recurso en función de la entrada en R.java: R.nombre_Metodo.variable_Estática.

  

Hay que tener en cuenta que los archivos que vayamos a crear como recursos deben seguir una nomenclatura determinada ya que no se va a permitir que  el nombre del archivo empiece por un valor numérico por poner un ejemplo, o que contenga mayúsculas.

La carpeta assets

En esta carpeta depositaremos todos los archivos que vayamos a querer que acompañen a la aplicación, pueden estar organizados en carpetas y serán empaquetados en el apk final. Podemos considerarlos como recursos al igual que el contenido de la carpeta res, pero no estarán indexados ni compilados de modo que el acceso a estos es menos eficiente y algo más laborioso. Por otro lado no tendremos que aplicar las reglas de los recursos en lo que respecta a nomenclaturas y organización.

La carpeta gen

Esta es una carpeta de código fuente que va a contener archivos de Java como la carpeta src, pero no deberemos agregar o modificar los archivos contenidos ya que son generados automáticamente por el plugin de Android a partir del contenido de la carpeta res. Aquí encontramos el archivo R que es el archivo de java que servirá para indexar e identificar a todos y cada uno de los recursos de la carpeta res.

AndroidManifest.xml

AndroidManifest.xml- El archivo Manifest es el más importante para nuestra aplicación, es la columna vertebral de nuestro proyecto, en él declaramos todas las actividades del proyecto, los permisos, versiones del SDK que usamos y un montón de cosas que vamos a ver más en detalle.