movil

Vincular Android con eclipse

Nota antes de empezar: antes de continuar con el tutorial, decirte que existe un paquete que incluye Eclipse, con el ADT y el SDK ya todo perfectamente montado y funcionando. Puedes descargar el paquete “Eclipse+plugin ADT+SDK” desde: http://developer.android.com/sdk/index.html . Es tan fácil como: descomprimir el contenido en una carpeta del disco duro, y e ir a la carpeta “IDE”, luego a la carpeta “eclipse” y ejecutar el archivo “eclipse.exe”. Con lo que si quieres saltarte todo este tutorial puedes simplemente con esto. Si quieres aprender, y seguramente te sirva como a mí para librarte de muchos problemas posteriores, completa este tutorial al menos una vez; así entenderás los entresijos del desarrollo de Android. En futuras instalaciones usa este paquete y termina antes

Una nota breve más: Existe otro entorno de trabajo más nuevo llamado Android Studio, que podéis ver como se usa e instala en vídeo pinchando aquí. En apariencia es diferente a Eclipse, pero mucho más lejos de la realidad, prácticamente se puede decir que es lo mismo y más moderno. Para los que se inicien en Android recomiendo Eclipse antes que Android Stuidio, pues está en Beta y carece de algunas funcionalidades importantes (como el editor del AndroidManifest.xml).

Para este tutorial vamos a mostrar como instalar el SDK de Android en la versión r20 -versiones posteriores también debería de funcionar, pero antiguas hay algunas cosas que cambian ligeramente- en Eclipse Indigo -En versiones anteriores de Eclipse es igual, solo cambian los vínculos de obtención de datos que veremos más adelante, también es igual con las posteriores versiones como en Eclipse Juno.

Por razón de cambios de versiones de Android y de Eclipse, suele variar la manera de instalación. Por lo que intentaremos mantener este tutorial lo más actualizado posible a las últimas versiones.

Para empezar, aseguramos que tenemos instalado Eclipse -es necesario, ya que el SDK de Android es un plugin de este, dicho de otro modo, es una herramienta que viene aparte- junto a Java y el JDK de Java, del tutorial anterior.

Continuamos descargando el SDK de Android de: http://developer.android.com/sdk/index.html

Ejecutamos el instalador y pulsamos una vez en “Next”.

Si detecta el instalador que el JDK de Java está instalado. Sería lo ideal y pulsamos otra vez en “Next”

Si no detecta el JDK de Java(Error: Java SE Development Kit (JDK) not found), por lo que el instalador no nos dejará continuar. Esto a su vez se traduce en dos posibles causas:

Para ver como solventar este error (tanto en Windows 8 como en versiones anteriores a Windows) vamos a la solución aquí.

Una vez llegado al punto de elegir ruta, recomiendo encarecidamente que se instale directamente en la raíz de la unidad que arranque el sistema operativo, para evitar problemas futuros. Normalmente es la unidad “C”. Bastará con poner “C:android-sdk” para que se cree en una carpeta que se llame “android-sdk”.

Ya pulsamos las veces que faltan “Next” hasta que se instale. Cuando se instale continuar, y cuando arrancamos el SDK cuando el instalador llegue al final y diga que si queremos ejecutar el SDK -que tenga la casilla marcada “Start SDK Manager (to dwnload system images, etc.)”- le decimos que terminar.

En este momento habremos instalado el SDK de Android. Se nos abrirá una parte del SDK que se llama “Android SDK Manager”, que estará vacío, es decir, que no tiene ningún sistema operativo Android como tal.

Esperamos a que la barra busque en Internet lo que podemos descargar. Para que funcione el emulador necesitamos al menos un sistema operativo.

Cuando acabe de buscar, se nos darán algunas opciones ya marcadas para instalar. Por defecto querrán instalarse los drivers de USB para poder probar las aplicaciones en el algún dispositivo físico con Android que tengamos, y la última versión de Android hasta la fecha.

Aunque suena muy jugosa la última versión de Android, usarla implica aceptar una serie de problemas:

1. Si tu ordenador no es muy potente, puede que desesperes de lo lento que va a ir el emulador de Android con el nuevo sistema operativo.
2. Si quieres subir a la Market (Play se llama ahora) la aplicación que desarrolles para esta versión, te vas a encontrar que muy poca gente se la va a descargar, pues casi nadie tiene esta última versión hasta que no pasa cerca de un año desde que salió.

Por lo que recomiendo apostar fuerte e instalar la versión 2.1 como mínimo, con lo que aseguramos rapidez en el emulador y que pueda ser usado por mucha gente. Ya que las versiones más nuevas de Android ejecutan aplicaciones escritas para versiones del sistema operativo más antiguas, pero no al revés. Y si miramos la gráfica de uso de las versiones de Android compensa a día de hoy al tener cerca del 90% del mercado:http://developer.android.com/resources/dashboard/platform-versions.html

Por lo que si queremos instalar el 2.1 por ejemplo, marcamos su casilla. Y marcamos otras casillas que nos puedan interesar. Podemos marcar todas para probar, pero se descargarán varios Gigas -todo es algo más de unos 4 GB. Con lo que recomiendo pensarlo, dependiendo de lo que queramos, el tiempo que dispongamos y nuestra conexión a internet.

Pulsamos el botón de “install X packages…”. Se abrirá una nueva ventana en la que aceptaremos todo -se puede pulsar sobre “Acept All”- pulsamos “Install” -si no nos deja, será porque existe algún paquete que dependa de otro no instalado, nos fijamos en cual es, cancelamos, desmarcamos su casilla y rehacemos los pasos- y esperamos.

Puede que durante la instalación se nos abra un recuadro pidiéndonos usuario y contraseña entre otra información; como no tenemos nada de eso pulsamos “Cancelar”, esa parte no se instalará (no es importante, son privadas y algunas de pago), continuará el resto.

Mientras se instala, comentar que tenemos dos programas que son individuales, nada vinculados:

1. Por un lado tenemos el SDK de Android -la ventana que tenemos descargando es el asistente de descargas, forma parte del SDK de Android.
2. Por otro lado tenemos Eclipse. Si lo abrimos veremos que no hay nada nuevo. Quiere decir que no hay nada vinculado con Eclipse, por lo tanto, tenemos que vincularlo para que se reconozcan entre ellos.

Cuando se haya descargado todo lo que queremos cerramos la ventana de “Android SDK Manager”.

Ahora trabajaremos con Eclipse, hay que vincular el SDK a nuestro entorno de desarrollo. Esto se realiza mediante la instalación de unplugin para Eclipse denominado ADT (Android Developent Tools). Tiene lógica que el plugin sean las herramientas de desarrollo de Android, ya que Eclipse como entorno de trabajo requiere de estas herramientas que no tiene para programar en Android.

En el menú vamos a “Help”, ahí elegimos “Install New Software…”

Se nos abrirá una nueva ventana. Pulsamos en “Add…”, y en la mini-ventana emergente que nos sale le ponemos el nombre que queramos que tenga el Plugin -Como por ejemplo: “ADT para vincular con el SDK de Android”. En el campo URL la siguiente dirección para descargar el plugin del ADT:

https://dl-ssl.google.com/android/eclipse/

Cuando acabemos aceptamos la mini-ventana emergente.

Ahora marcamos la casilla de “Developer Tools” para que se marquen todas y pulsamos en siguiente.

En el siguiente paso pulsamos directamente a siguiente.

Llegaremos a otro paso que tenemos que aceptar la licencia y pulsamos terminar.

Entonces empezará la instalación. Seguramente a mitad de la instalación nos salga una ventana de advertencia avisándonos que existe contenido no firmado y que no puede validarlo, simplemente pulsamos en “OK” y esperamos a que termine.

Al terminar nos pedirá reiniciar Eclipse. Le decimos que reinicie ahora.

Al reiniciarse Eclipse nos saldrá una ventana que nos dirá que si queremos instalar el SDK. El SDK ya está instalado, con lo que pulsamos en “Use existing SDKs” y elegimos la carpeta donde instalamos anteriormente el SDK.

En la siguiente ventana nos preguntará si queremos enviar estadísticas de uso a Google. Si queremos colaborar con Google le decimos que sí, sino que no y pulsamos en terminar.

Ya tenemos vinculados Eclipse con el SDK de Android.

Con un vistazo rápido a Eclipse veremos las nuevas herramientas instaladas, a las cuales podremos acceder desde diferentes lugares.

No aparecen los iconos de Android: Puede que no te aparezcan los iconos ni del Android SDK Manager ni del AVD Manager (Android Virtual Device Manager). Para verlos tienes como hacer que aparezcan en este otro artículo.

Está todo instalado. Ahora queda preparar las herramientas de nuestro entorno de desarrollo y conocerlas. Síguelo en el siguiente artículo llamado para preparar las herramientas necesarias para programar en Android.

Nota: el emulador de Android suele tardar bastante en cargar y por norma es lento. Puedes ver como configurar el emulador de Android para que vaya muy más deprisa en este artículo.

Dirección de la información

http://jarroba.com/instalar-el-sdk-de-android-y-vincularlo-con-eclipse/

CICLOS for

• El ciclo for repite una declaración o bloque de enunciados un número de veces hasta que una condición se cumple.
• Estos ciclos con frecuencia se usan para una iteración sencilla en donde se repite un bloque de enunciados un cierto número de veces y después se detiene, aunque también se los puede usar para cualquier clase de ciclo.
• Formato:

for (inicialización; test; incremento) {

sentencias;

}

• El inicio del ciclo for tiene tres partes:
• inicialización es una expresión que inicializa el principio del ciclo. Si se tiene un índice, esta expresión puede ser declarada e inicializada, int i = 0. Las variables que se declaran en esta parte del ciclo son locales al ciclo: dejan de existir después de acabar la ejecución del mismo.
• test es la prueba que ocurre después de cada vuelta del ciclo. La prueba debe ser una expresión booleana o una función que regresa un valor booleano, por ejemplo, i < 10. Si la prueba es verdadera, el ciclo se ejecuta; cuando es falsa, el ciclo detiene su ejecución.
• incremento es una expresión o llamada de función. Por lo común, el incremento se utiliza para cambiar el valor del índice del ciclo a fin de acercar el estado del ciclo a false y que se complete.
• Dentro del ciclo for existen sentencias que se ejecutan cada vez que se itera el ciclo. Al igual que con if, se puede incluir un solo enunciado o un bloque; en este último caso, como se sabe, se lo empieza y termina con llaves ({ }).
• Ejemplo. ciclo for para inicializar todos los valores de un arreglo String para cadenas vacías:

String strArray [ ] = new String[10];

int i; // índice del lazo

for (i = 0; i < strArray.length; i++)

strArray[i] = "";

• Cualquier parte del ciclo for puede se un enunciado vacío, esto es, puede incluir sólo un punto y coma sin ninguna expresión o declaración, y esa parte del ciclo se ignorará.
• También puede tenerse un enunciado vacío para el cuerpo del ciclo for, si todo lo que se desea hacer se encuentra en la primera línea. Por ejemplo, aquí está una que encuentra el primer número primo mayor que 4000:

for (i = 40001; notPrime(i); i +=2)

;

CICLOS while y do

• Estos ciclos permiten también a un bloque de código ejecutarse de manera repetida hasta encontrar una condición específica. Utilizar uno de estos tres ciclos es, por lo general, una cuestión de estilo de programación.
• Los ciclos while y do son exactamente los mismos que en C y C++, a excepción de que su condición de prueba debe ser un booleano.

CICLOS while

• Se utilizan para repetir un enunciado o bloque de enunciados, mientras una condición sea verdadera.
• Formato:

while (condición) {

cuerpoDelLazo;

}

• La condición es una expresión booleana. Si regresa true, el ciclo while ejecuta los enunciados en cuerpoDelLazo y después prueba la condición hasta que ésta sea falsa. También se puede emplear un enunciado sencillo en lugar del bloque.
• Ejemplo. Inicialización y escritura de un vector:

int [ ] A = new int[10];

for (int j = 0; j < A.length; j++)

A[ j ] = j + 2;

int i = 0;

while (i < A.length)

System.out.println("A[ " + i + " ] = " + A[i]);

• Si la condición la primera vez que se prueba es falsa, el cuerpo del ciclo while nunca se ejecutará.
• Para este caso, cuando se desee que una iteración se ejecute por lo menos una vez, se utiliza el ciclo do ... while, como se explica a continuación.

CICLOS do ... while

• El ciclo do es como el ciclo while, excepto que ejecuta un enunciado o bloque dado hasta que la condición es false.
• La principal diferencia es que los ciclos while prueban la condición antes de realizar el ciclo, lo cual hace posible que el cuerpo del ciclo nunca se ejecute si la condición es falsa la primera vez que se prueba.
• Los ciclos do ejecutan el cuerpo del ciclo por lo menos una vez antes de probar la condición.
• Formato:

do {

cuerpoDelLazo;

} while (condición);

• cuerpoDelLazo se ejecuta por lo menos una vez.
• La condición se prueba al final de la ejecución del cuerpo.
• La condición es una prueba booleana: si regresa true, el ciclo se ejecuta otra vez; si regresa false, se detiene.

Ejemplo:

int x = 1;

do {

System.out.println("Lazo, vuelta " + x);

x++;

} while (x <= 10);

SALIDA DE CICLOS

• Todos los ciclos (for, while y do) se terminan cuando la condición que prueba se cumple.
• Para salir del ciclo de manera incondicional, se usan las palabras clave break y continue.
• break detiene la ejecución del ciclo actual. Si se anidaron ciclos, la ejecución selecciona el siguiente ciclo externo; de otra manera, el programa continúa la ejecución del siguiente enunciado después del ciclo.
• Ejemplo: copia de elementos de un arreglo de números enteros a un arreglo de punto flotante hasta el final del arreglo o hasta que se encuentre un 0.

int count = 0;

while (count < array1.length) {

if (array1[count] ==0) {

break;

}

array2[count] = (float) array1[count++];

}

• El uso de continue es similar al de break, a excepción de que en lugar de detener por completo la ejecución del ciclo, éste inicia otra vez la siguiente iteración.
• Para los ciclos do y while, esto significa que la ejecución del bloque se inicia de nuevo.
• Para los ciclos for, la expresión de incremento se evalúa y después el bloque se ejecuta.
• continue es útil cuando se desea tener elementos especiales de condición dentro de un ciclo.
• Usando el ejemplo anterior, se puede probar si el elemento actual es 0 y reiniciar el ciclo si lo encuentra, para que el arreglo resultante nunca contenga cero. Obsérvese que puesto que en el primer arreglo se saltan los elementos, ahora se tiene que seguir a dos diferentes contadores de arreglos:

int count1 = 0;

int count2 = 0;

while (count1 < array1.length) {

if (array1[count1] ==0) {

count1++;

continue;

}

array2[count2++] = (float) array1[count1++];

}

CICLOS ETIQUETADOS

• Tanto break como continue pueden tener una etiqueta opcional que le indique a Java dónde detenerse.
• Sin una etiqueta, break saltará hacia el ciclo más cercano (a uno envolvente o al siguiente enunciado fuera del ciclo) y continue reinicia el ciclo envolvente.
• Utilizar estas instrucciones etiquetadas, permite salirse de ciclos anidados o continuar un ciclo fuera del actual.
• Para utilizar un ciclo etiquetado, se agrega la etiqueta antes de la parte inicial del mismo, con dos puntos entre ellos.
• Después, cuando se utilice break o continue, se agrega el nombre de la etiqueta, después de la palabra clave:

out:

for (int i = 0; i < 10; i++) {

while (x < 50) {

if (i * x == 400)

break out;

. . .

}

. . .

}

• En este recorte de código, la etiqueta out marca el ciclo externo. Entonces, dentro de los ciclos for y while, cuando una condición particular se cumple, un break ocasiona que la ejecución se salga de ambos ciclos.
• El siguiente programa contiene un ciclo anidado for. Dentro del ciclo más profundo, si los valores sumados de los dos contadores es mayor que cuatro, ambos ciclos se abandonan al mismo tiempo:

foo:

for (int i = 1, i <= 5; i++)

for (int j = 1; j <= 3; j++) {

System.out.println(" i es " + i + ", j es " + j);

if (i + j) > 4)

break foo;

}

System.out.println("fin de lazos");

Salida del programa:

i es 1, j es 1

i es 1, j es 2

i es 1, j es 3

i es 2, j es 1

i es 2, j es 2

i es 2, j es 3

fin de lazos

• Como se puede ver, el ciclo se iteró hasta que la suma de i y j fue mayor que 4 y después ambos regresaron al bloque externo y el mensaje final se imprimió.

Comparativa con otras plataformas

En este apartado vamos a describir las características de las principales plataformas móviles disponibles en la actualidad. Dado la gran cantidad de datos que se indican, hemos utilizado una tabla para representar la información. De esta forma resulta más sencillo comparar las plataformas.

Tabla 1:Comparativa de las principales plataformas móviles

Otro aspecto fundamental a la hora de comparar las plataformas móviles es su cuota de mercado. En la siguiente gráfica podemos ver un estudio realizado por la empresa Gartner Group, donde se muestra la evolución del mercado de los sistemas operativos para móviles según el número de terminales vendidos. Podemos destacar la desaparición de la plataforma Symbian de Nokia, el declive continuo de BlackBerry, el estancamiento de la plataforma de Windows, que parece que no despega, y el afianzamiento de la cuota de mercado de Apple en torno al 20%. Finalmente, cabe señalar el espectacular ascenso de la plataforma Android, que en cinco años ha alcanzado una cuota de mercado en torno al 85%.

Depurar una aplicación Android con Eclipse

Programación y errores de código es un binomio inseparable. Por lo tanto, resulta fundamental sacar el máximo provechos a las herramientas de depuración.

Depurar con Eclipse

El plug-in de Android para Eclipse tiene una excelente integración con el depurador de Eclipse. Introduce un error en tu código modificando el código fuente de MainActivity para que en método onCreate tenga este este código:

1. @Override
2. public void onCreate(Bundle savedInstanceState) {
3. super.onCreate(savedInstanceState);
4. Object o = null;
5. o.toString();
6. setContentView(R.layout.activity_main);
7. }

Este cambio introduce un NullPointerException en tu código. Si ahora ejecutas tu aplicación, te aparecerá esto:

Pulsa Force Close para finalizar la aplicación. Para averiguar más sobre el error, inserta un punto de ruptura (breakpoint) en el código fuente en la línea Object o = null; (el breakpoint se introduce haciendo doble clic en la barra de la izquierda). Entonces selecciona Run / Debug History / HolaMundo para ejecutarlo en modo debug. Tu aplicación se reiniciará en el emulador, pero esta vez quedará suspendida cuando alcance el punto de ruptura que se ha introducido. Entonces puedes recorrer el código en modo Debug, igual que se haría en cualquier otro entorno de programación.

Creación de una interfaz de usuario por código

Veamos un primer ejemplo de cómo crear una interfaz de usuario utilizando exclusivamente código Java. Aunque esta no es la forma recomendable de trabajar con Android, resulta interesante para resaltar algunos conceptos.

1. Abre el proyecto creado en el capítulo anterior y visualiza MainActivity.java.

2. Comenta la última sentencia del método onCreate() añade las tres que se muestran a continuación en negrita:

1. @Override
2. public void onCreate(Bundle savedInstanceState) {
3. super.onCreate(savedInstanceState);
4. //setContentView(R.layout.activity_main);
5. TextView texto = new TextView(this);
6. texto.setText("Hello, Android");
7. setContentView(texto);
8. }

Nota sobre Java: Para poder utilizar el objeto TextView has de importar un nuevo paquete. Para ello añade al principio “import android.widget.TextView;”. Otra alternativa es pulsar Alt-Intro en Android Studio o Ctrl-Shift-O enEclipse, para que se añadan automáticamente los paquetes que faltan.

La interfaz de usuario de Android está basada en una jerarquía de clases descendientes de la clase View(vista). Una vista es un objeto que se puede dibujar y se utiliza como un elemento en el diseño de la interfaz de usuario (un botón, una imagen, una etiqueta de texto como en el utilizado en el ejemplo,…). Cada uno de estos elementos se define como una subclase de la clase View; la subclase para representar un texto es TextView.

El ejemplo comienza creando un objeto de la clase TextView. El constructor de la clase acepta como parámetro una instancia de la clase Context (contexto). Un contexto es un manejador del sistema que proporciona servicios como la resolución de recursos, obtención de acceso a bases de datos o preferencias. La claseActivity es una subclase de Context, y como la clase MainActivity es una subclase de Activity, también es tipo Context. Por ello, puedes pasar this (el objeto actual de la clase MainActivity) como contexto delTextView.

3. Después se define el contenido del texto que se visualizará en el TextView mediante setText(). Finalmente, mediante setContentView()se indica la vista utilizada por la actividad.

4. Ejecuta el proyecto para verificar que funciona.

Edición visual de las vistas

Veamos ahora como editar los layouts o ficheros de diseño en XML. En el explorador del proyecto abre el fichero res/layout/activity_main.xml. Verás que en la parte inferior de la ventana central aparecen dos lengüetas: Design y Text en Android Studio; Graphical Layout y activity_main.xml en Eclipse. Podrás usar dos tipos de diseño: editar directamente el código XML (segunda lengüeta) o realizar este diseño de forma visual (primera lengüeta). Veamos cómo se realizaría el diseño visual. Aunque puede cambiar el orden de algunos elementos, la herramienta de edición de layouts es prácticamente idéntica enAndroid Studio:

Y en Eclipse:

En el marco derecho se visualiza una lista con todos los elementos del layout. Este layout tiene solo dos vistas: un RelativeLayout conteniendo un TextView. En este momento solo hay dos un RelativeLayoutque contiene un TextView. En el marco central aparece una representación de cómo se verá el resultado. En la parte superior aparecen varios controles para representar esta vista en diferentes configuraciones. Cuando diseñamos una vista en Android, hay que tener en cuenta que desconocemos el dispositivo final donde será visualizada y la configuración específica elegida por el usuario. Por esta razón, resulta importante que verifiques que la vista se ve de forma adecuada en cualquier configuración. En la parte superior, de izquierda a derecha, encontramos los siguientes botones: opciones de previsualización en fase de diseño, tipo de dispositivo (tamaño y resolución de la pantalla), orientación horizontal (landscape) o vertical (portrait),

cómo se verá nuestra vista tras aplicar un tema, la actividad asociada, la configuración regional (locale), la versión de Android.

Para editar un elemento, selecciónalo en el marco de la derecha (Outline) o pincha directamente sobre él en la ventana de previsualización. Al seleccionarlo, puedes modificar alguna de sus propiedades en el marco Properties, situado debajo de Outline. Echa un vistazo a las propiedades disponibles para TextView y modifica alguna de ellas. En muchos casos te aparecerá un desplegable con las opciones disponibles.

El marco de la izquierda te permite insertar de forma rápida nuevas vistas al layout. Puedes arrastrar cualquier elemento a la ventana de previsualización o al marco Outline. En el anexo D se ha incluido una lista con las vistas disponibles.

Layouts

Si queremos combinar varios elementos de tipo vista tendremos que utilizar un objeto de tipo Layout. Un Layoutes un contenedor de una o más vistas y controla su comportamiento y posición. Hay que destacar que un Layoutpuede contener a otro Layout y que es un descendiente de la clase View.

La siguiente lista describe los Layout más utilizados en Android:

LinearLayout: Dispone los elementos en una fila o en una columna.

TableLayout: Distribuye los elementos de forma tabular.

RelativeLayout: Dispone los elementos en relación a otro o al padre.

AbsoluteLayout: Posiciona los elementos de forma absoluta.

FrameLayout: Permite el cambio dinámico de los elementos que contiene.

Dado que un ejemplo vale más que mil palabras, pasemos a mostrar cada uno de estos layouts en acción:

LinearLayout es uno de los Layout más utilizado en la práctica. Distribuye los elementos uno detrás de otro, bien de forma horizontal o vertical.

1. <LinearLayout xmlns:android="http://...
2. android:layout_height="match_parent"
3. android:layout_width="match_parent"
4. android:orientation ="vertical">
5. <AnalogClock
6. android:layout_width="wrap_content"
7. android:layout_height="wrap_content"/>
8. <CheckBox
9. android:layout_width="wrap_content"
10. android:layout_height="wrap_content"
11. android:text="Un checkBox"/>
12. <Button
13. android:layout_width="wrap_content"
14. android:layout_height="wrap_content"
15. android:text="Un botón"/>
16. <TextView
17. android:layout_width="wrap_content"
18. android:layout_height="wrap_content"
19. android:text="Un texto cualquiera"/>
20. </LinearLayout>

TableLayout distribuye los elementos de forma tabular. Se utiliza la etiqueta <TableRow> cada vez que queremos insertar una nueva línea.

1. <TableLayout xmlns:android=”http://...
2. android:layout_height="match_parent"
3. android:layout_width="match_parent">
4. <TableRow>
5. <AnalogClock
6. android:layout_width="wrap_content"
7. android:layout_height="wrap_content"/>
8. <CheckBox
9. android:layout_width="wrap_content"
10. android:layout_height="wrap_content"
11. android:text="Un checkBox"/>
12. </TableRow>
13. <TableRow>
14. <Button
15. android:layout_width="wrap_content"
16. android:layout_height="wrap_content"
17. android:text="Un botón"/>
18. <TextView
19. android:layout_width="wrap_content"
20. android:layout_height="wrap_content"
21. android:text="Un texto cualquiera"/>
22. </TableRow>
23. </TableLayout>

RelativeLayout permite comenzar a situar los elementos en cualquiera de los cuatro lados del contenedor e ir añadiendo nuevos elementos pegados a estos.

1. <RelativeLayout xmlns:android="http://schemas...
2. android:layout_height="match_parent"
3. android:layout_width="match_parent">
4. <AnalogClock
5. android:id="@+id/AnalogClock01"
6. android:layout_width="wrap_content"
7. android:layout_height="wrap_content"
8. android:layout_alignParentTop="true"/>
9. <CheckBox
10. android:id="@+id/CheckBox01"
11. android:layout_width="wrap_content"
12. android:layout_height="wrap_content"
13. android:layout_below="@+id/AnalogClock01"
14. android:text="Un checkBox"/>
15. <Button
16. android:id="@+id/Button01"
17. android:layout_width="wrap_content"
18. android:layout_height="wrap_content"
19. android:text="Un botón"
20. android:layout_below="@+id/CheckBox01"/>
21. <TextView
22. android:id="@+id/TextView01"
23. android:layout_width="wrap_content"
24. android:layout_height="wrap_content"
25. android:layout_alignParentBottom="true"
26. android:text="Un texto cualquiera"/>
27. </RelativeLayout>

AbsoluteLayout permite indicar las coordenadas (x,y) donde queremos que se visualice cada elemento. No es recomendable utilizar este tipo de Layout. La aplicación que estamos diseñando tiene que visualizarse correctamente en dispositivos con cualquier tamaño de pantalla. Para conseguir esto, no es una buena idea trabajar con coordenadas absolutas. De hecho, este tipo de Layout ha sido marcado como obsoleto.

1. <AbsoluteLayout xmlns:android="http://schemas.
2. android:layout_height="match_parent"
3. android:layout_width="match_parent">
4. <AnalogClock
5. android:layout_width="wrap_content"
6. android:layout_height="wrap_content"
7. android:layout_x="50px"
8. android:layout_y="50px"/>
9. <CheckBox
10. android:layout_width="wrap_content"
11. android:layout_height="wrap_content"
12. android:text="Un checkBox"
13. android:layout_x="150px"
14. android:layout_y="50px"/>
15. <Button
16. android:layout_width="wrap_content"
17. android:layout_height="wrap_content"
18. android:text="Un botón"
19. android:layout_x="50px"
20. android:layout_y="250px"/>
21. <TextView
22. android:layout_width="wrap_content"
23. android:layout_height="wrap_content"
24. android:text="Un texto cualquiera"
25. android:layout_x="150px"
26. android:layout_y="200px"/>
27. </AbsoluteLayout>

FrameLayout posiciona las vistas usando todo el contenedor, sin distribuirlas espacialmente. Este Layout suele utilizarse cuando queremos que varias vistas ocupen un mismo lugar. Podemos hacer que solo una sea visible, o superponerlas.Para modificar la visibilidad de un elemento utilizaremos la propiedad visibility.

1. <FrameLayout xmlns:android="http://schemas...
2. android:layout_height="mach_parent"
3. android:layout_width="match_parent">
4. <AnalogClock
5. android:layout_width="wrap_content"
6. android:layout_height="wrap_content"/>
7. <CheckBox
8. android:layout_width="wrap_content"
9. android:layout_height="wrap_content"
10. android:text="Un checkBox"/>
11. <Button
12. android:layout_width="wrap_content"
13. android:layout_height="wrap_content"
14. android:text="Un botón"
15. android:visibility="invisible"/>
16. <TextView
17. android:layout_width="wrap_content"
18. android:layout_height="wrap_content"
19. android:text="Un texto cualquiera"
20. android:visibility="invisible"/>
21. </FrameLayout>

1. Utiliza un RelativeLayout para realizar un diseño similar al siguiente:

2. Utiliza un TableLayout para realizar un diseño similar al siguiente:

3. Utiliza un LinearLayout horizontal que contenga en su interior otros LinearLayout para realizar un diseño similar al siguiente:

4. Visualiza el resultado obtenido en diferentes tamaños de pantalla. ¿Se visualiza correctamente?

Drawable

La clase Drawable es una abstracción que representa “algo que puede ser dibujado”. Esta clase se extiende para definir gran variedad de objetos gráficos más específicos. Muchos de ellos pueden ser definidos como recursos usando ficheros XML. Entre ellos tenemos los siguientes:

BitmapDrawable: Imagen basada en un fichero gráfico (PNG o JPG). Etiqueta XML <bitmap>.

ShapeDrawable: Permite realizar un gráfico a partir de primitivas vectoriales, como formas básicas (círculos, cuadrados,…) o trazados (Path). No puede ser definido mediante un fichero XML.

LayerDrawable: Contiene un array de Drawable que son visualizados según el orden del array. El índice mayor del array es el que se representa encima. Cada Drawable puede situarse en una posición determinada. Etiqueta XML<layer-list>

StateListDrawable: Similar al anterior pero ahora podemos usar una máscara de bits podemos seleccionar los objetos visibles. Etiqueta XML <selector>.

GradientDrawable: Degradado de color que puede ser usado en botones o fondos.

TransitionDrawable: Una extensión de LayerDrawables que permite un efecto de fundido entre la primera y la segunda capa. Para iniciar la transición hay que llamar a startTransition(inttiempo). Para visualizar la primera capa hay que llamar a resetTransition(). Etiqueta XML<transition>.

AnimationDrawable: Permite crear animaciones frame a frame a partir de una serie de objetosDrawable. Etiqueta XML <animation-list>

También puede ser interesante que uses la clase Drawable o uno de sus descendientes como base para crear tus propias clases gráficas.

Además de ser dibujada, la clase Drawable proporciona una serie de mecanismos genéricos que permiten indicar como ha de ser dibujada. No todo Drawable ha de implementar todos los mecanismos. Veamos los más importantes:

El método setBounds(x1,y1,x2,y2) permite indicar el rectángulo donde ha de ser dibujado. Todo Drawable debe respetar el tamaño solicitado por el cliente, es decir, ha de permitir el escalado. Podemos consultar el tamaño preferido de un Drawable mediante los métodosgetIntrinsicHeight() y getIntrinsicWidth().

El método getPadding(Rect) nos proporciona información sobre los márgenes recomendados para representar contenidos. Por ejemplo, un Drawable que intente ser un marco para un botón, debe devolver los márgenes correctos para localizar las etiquetas, u otros contenidos, en el interior del botón.

El método setState(int[]) permite indicar al Drawable en qué estado ha de ser dibujado, por ejemplo "con foco", "seleccionado", etc. Algunos Drawable cambiarán su representación según este estado.

El método setLevel(int) permite implementar un controlador sencillo para indicar como se representará el Drawable. Por ejemplo, un nivel puede ser interpretado como una batería de niveles o un nivel de progreso. Algunos Drawable modificarán la imagen basándose en el nivel.

Un Drawable puede realizar animaciones al ser llamado desde el cliente a su métodoDrawable.Callback. Todo cliente debe implementar esta interfaz (viasetCallback(Drawable.Callback)). El sistema nos facilita realizar esta tarea de forma sencilla a través de setBackgroundDrawable( Drawable) e ImageView.

GUÍA DEL SEGUNDO PARCIAL

¿Cuál de los siguientes nombres comerciales apareció en primer lugar?

Froyo

Cupcake

Éclair

Jelly Bean

¿Qué versión de Android es exclusiva para tabletas?

Android 2.0, Éclair, nivel de API 7

Android 2.2, Froyo, nivel de API 8

Android 3.0, Honeycomb, nivel de API 11

Android 4.0, Ice Cream Sandwich, nivel de API 14

¿Qué importante novedad se introduce en la versión de Android 4.4 KitKat?

Una Nueva máquina virtual (ART) para ejecutar código Java más rápido

Se rompe el orden alfabético, que se llevaba hasta la fecha, para hacer propaganda a este producto de Nestlé

Se introduce el uso de fragments

Todas las respuestas son ciertas

¿Cuál es la forma recomendable de diseñar el interfaz de usuario en Android?

Utilizando un lenguaje de marcado HTML

Utilizando un lenguaje de marcado en XML diseñado para este propósito

Usar software de diseño de páginas Web

Utilizando código Java

¿Cuál NO es una ventaja de diseñar el interfaz de usuario en XML en lugar de en código?

Se pueden conseguir interfaces mucho más fáciles de utilizar

Permite que los diseñadores trabajen de forma independiente a los programadores

Permite utilizar herramientas gráficas de diseño

Se acelera la fase de diseño

¿Para qué se utiliza la siguiente sentencia de Java setContentView(R.layout.activity_main);?

Permite definir el interfaz de usuario de la actividad utilizando exclusivamente código Java

Crea el fichero R.java a partir del Layout definido

Se crearán todos los objetos que han sido definidos en el fichero res/layout/activity_main.xml y se asocian a la actividad para que los visualice.

No sirve para nada de lo indicado

¿Qué función tiene la clase R.java?

Almacenar los recursos en su interior, por lo que puede ser muy grande

Es la responsable de representar el interfaz de usuario

Realiza una conversión de XML a código alfanumérico

Permite acceder a los recursos desde código Java

¿De qué tipo son los identificadores de recursos definidos en el fichero R.java?

Un valor entero

Un puntero a memoria

Una clase

Un fichero XML

¿Cuándo has de modificar el fichero R.java?

Siempre que hay que definir un identificador de recurso nuevo

Siempre que cambia un recurso

Nunca

Cuando se editan visualmente las vistas

¿Cómo se escoge los nombres de los identificadores de recurso?

Generalmente se utiliza el nombre del fichero del recurso quitándole la extensión

Generalmente se utiliza el nombre de la carpeta que contiene el recurso

Generalmente se utiliza el sufijos de la carpeta del recurso alternativo

¿Qué ventana de Eclipse tenemos que utilizar para modificar los atributos de las vistas?

Properties (propiedades)

Outline (esquema)

Palette (paleta)

Grafical Layout (diseño gráfico)

¿Qué ventana de Eclipse tenemos que utilizar para consultar y modificar la estructura de layouts y vistas?

Properties (propiedades)

Outline (esquema)

Palette (paleta)

Grafical Layout (diseño gráfico)

En la barra superior del editor visual de layouts aparecen una serie de desplegables ¿Qué finalidad tienen?

Define varios parámetros del Layout: tipo de pantalla / orientación de la pantalla / Tema / Actividad …

Permite definir un recurso alternativo para una configuración específica: tipo de pantalla / orientación de la pantalla / Tema / Actividad …

Permite definir algunos atributos de la vista: tipo de pantalla / orientación de la pantalla / / Tema / Actividad …

Muestra como quedaría la vista en diferentes tipos de pantallas / orientación de la pantalla / Tema / Actividad…

Cuál es la forma recomendable de establecer la propiedad layout_width.

Indicando una dimensión concreta en pixels, por ejemplo 200px

Indicando una dimensión concreta en mm, por ejemplo 200mm

Utilizando uno de los valores match_parent o fill_parent.

Utilizando uno de los valores wrap_content o fill_parent.

Cuál de los siguientes atributos se aplica al texto de la vista, pero no a la vista en sí.

visibility

style

gravity

layout_gravity

Cuál de los siguientes atributos modificará la forma en la que se visualizará la vista.

padding

id

clickable

on_click

Si queremos que no haya separación entre una serie de botones, para que aparezcan unos pegados a los otros, escribiremos:

layout_margin = "fill_parent"

layout_margin = "0px"

padding = "0px"

padding = "fill_parent"

¿Cuál de los siguientes Layouts superpone las vistas que contiene?

AbsoluteLayout

RelativeLayout

FrameLayout

LinearLayout

¿Cuál de los siguientes Layouts permite posicionar las vistas en función a donde estén otras?

AbsoluteLayout

RelativeLayout

FrameLayout

LinearLayout

¿Cuál de los siguientes Layouts se recomienda no usarlo en Android?

AbsoluteLayout

FrameLayout

LinearLayout

TableLayout

¿Cuál de los siguientes Layouts permite posicionar las vistas unas al lado de otras formando una fila o una columna?

AbsoluteLayout

FrameLayout

LinearLayout

TableLayout