Volver > SOFTWARE Curso online sencillo Desarrollo de Aplicaciones en Android | |



Curso online sencillo DESARROLLO DE APLICACIONES ANDROID.








3.10 Instalación de Eclipse con el SDK de Android

En este apartado se exponen los pasos necesarios para empezar a desarrollar y a entender aplicaciones para Android. Las instrucciones de instalación aquí descritas se basan en el sistema operativo Windows XP o Windows Vista, y en el entorno de desarrollo Eclipse Classic versión 3.4, conocida como Ganymede. Aunque esta guía de instalación no los contempla, el SDK de Android también puede correr en otros sistemas operativos como Mac OS X o Linux (verificado para Ubuntu 6.06 LTS).

3.10.1 Descargar el SDK de Android

Android es una plataforma de software libre, por lo que cuenta con un SDK disponible para todo desarrollador que lo desee que incluye, entre otros elementos, el conjunto completo de API que este sistema soporta. Para descargarlo, basta con visitar la web de Android [32] y asegurarse de acceder a la última versión publicada (durante la redacción de estas líneas, la última versión es la 1.0 de septiembre de 2008).
Una vez descargado el SDK, es necesario descomprimirlo. La ubicación de los ficheros resultantes no es relevante, pero conviene recordar la ruta para pasos posteriores.

3.10.2 Descargar Eclipse Ganymede

La descarga de Eclipse no es muy diferente al SDK de Android. La web de Eclipse [33] ofrece multitud de versiones de este entorno de desarrollo según las necesidades del desarrollador. En este caso, es suficiente con obtener la versión 3.4, denominada Ganymede.
Finalizada la descarga, no se realiza ningún proceso de instalación; simplemente se debe descomprimir los ficheros y pulsar el ejecutable para abrir la aplicación. La primera vez que se inicie Eclipse, pide al usuario una localización para el workspace, donde se ubicarán por defecto todos los proyectos desarrollados.

3.10.3 Instalar el plug-in de Android

El siguiente paso consisten en instalar un plug-in específico de Android para la plataforma Eclipse. Esta herramienta, llamada ADT (Android Development Tools), facilita enormemente la creación de proyectos, su implementación, depuración y ejecución, por lo que es altamente recomendable si se quiere trabajar con Android.
Para instalar el plug-in ADT en Eclipse Ganymede, es necesario seguir las siguientes indicaciones:

1. Iniciar Eclipse
2. Seleccionar la pestaña Help > Software Updates. Esta acción abrirá una nueva ventana llamada Software Updates and Add-ons.
3. Pinchar en la pestaña Available Software y pulsar el botón Add Site. 4. Introducir la siguiente URL y pulsar OK:

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

5. Volviendo a la ventana Software Updates and Add-ons, marcar la casilla correspondiente a Developer Tools y pulsar el botón Install. Se abrirá una nueva ventana.
6. Cerciorarse de que las opciones Android Developer Tools y Android Editors están marcadas y pulsar el botón Finish.

El proceso de instalación dará comienzo y puede llevar algunos minutos. Con el fin de que los cambios tengan efecto, es necesario reiniciar Eclipse.

3.10.4 Referenciar el SDK de Android

Tras abrir de nuevo Eclipse, debe indicarse en las preferencias de Eclipse la localización del SDK a utilizar para los proyectos de Android:

1. Seleccionar la pestaña Window > Preferences, lo que abrirá una nueva ventana.
2. Elegir Android en el panel izquierdo.
3. Pulsar el botón Browse e indicar la ruta del SDK de Android.
4. Pulsar el botón Apply y después OK.

3.10.5 Actualizaciones del plug-in

Es posible que con el tiempo haya disponible una nueva versión del ADT correspondiente a la versión del SDK de Android instalado. Para comprobar las posibles actualizaciones a través de Eclipse, se debe realizar lo siguiente:

1. Iniciar Eclipse.
2. Seleccionar la pestaña Help > Software Updates. Esta acción abrirá una nueva ventana llamada Software Updates and Add-ons.
3. Elegir la pestaña Installed Software.
4. Pulsar el botón Update.
5. Si existe alguna actualización para el ADT, seleccionarla y pulsar el botón Finish.

3.11 Primera aplicación en Android: “Hola Mundo”

La mejor forma de empezar a comprender las características de cualquier nuevo sistema o entorno de desarrollo es mediante la creación de un ejemplo sencillo. En este caso, y como viene siendo habitual, se creará una aplicación que mostrará por pantalla el mensaje “Hola Mundo”.
Además de ilustrar el funcionamiento de Android, se podrá comprobar la utilidad de disponer de una herramienta como el ADT para Eclipse y se explicarán los elementos que componen un proyecto para Android.

3.11.1 Crear un nuevo proyecto

La creación de un nuevo proyecto de Android no representa mayor dificultad que crear cualquier otro tipo de proyecto en Eclipse. Una vez abierto este entorno de desarrollo, deben realizarse los siguientes pasos:

1. Crear el proyecto
Seleccionar la pestaña File > New > Project, y en el menú resultante desplegar la opción Android y elegir Android Project. Pulsar el botón Next.

2. Especificar las propiedades
A continuación se muestra una ventana donde es necesario detallar algunas propiedades del proyecto. En concreto, se precisa asignar un valor para:
- Project name: es el nombre del proyecto. En la práctica, será el nombre que reciba la carpeta donde se guardará todo lo relativo al presente proyecto, dentro del workspace. Por ejemplo, “HolaMundo”.
- Package name: el nombre del paquete bajo el cual será desarrollado todo el código. Por ejemplo, se le puede asignar el valor “com.android.hola”.
- Activity name: es el nombre de la clase Activity que será creada de forma automática por el plug-in. Esta clase Activity simplemente es una clase ejecutable, capaz de realizar alguna tarea, y es imprescindible en la mayoría de las aplicaciones para Android. Por ejemplo, póngase el nombre “HolaMundo”.
- Application name: el nombre de la aplicación que se va a desarrollar. Constituye el nombre visible para el usuario del dispositivo móvil. Por ejemplo, “Saludo al Mundo”.

Tras pulsar el botón Finish, Eclipse mostrará en el explorador de paquetes los elementos que conforman el actual proyecto. Además, si se visita el workspace asignado para los proyectos de Eclipse, podrá observarse que existe una nueva carpeta denominada “HolaMundo”. El contenido de esta carpeta se explica más adelante.

3.11.2 Añadir una interfaz de usuario

Para continuar con el ejemplo, debe desplegarse en el explorador de paquetes la carpeta denominad “src”. En esta carpeta existirán dos ficheros: “HolaMundo.java” y “R.java”. Ambos constituyen hasta el momento los dos únicos ficheros fuente del proyecto.
Si se abre el fichero “HolaMundo.java”, puede encontrarse el siguiente código:

Aplicaciones Android
Código 5. Código inicial de “HolaMundo.java”

Este código es perfectamente ejecutable, pero para este ejemplo se van a añadir algunos cambios. El objetivo es crear una simple interfaz de usuario que permita mostrar el mensaje “Hola Mundo”. El nuevo código resultante ha de ser el siguiente:

package com.android.hola;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class HolaMundo extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView tv = new TextView(this);
tv.setText("Hola Mundo");
setContentView(tv);
}
}

Código 6. Código de HolaMundo.java modificado

En Android, las interfaces de usuario están formadas por una jerarquía de clases llamadas Views (vistas). Una vista o View representa cualquier elemento que se pueda dibujar en pantalla, como un botón, una animación, una etiqueta de texto, etc. En este ejemplo se crea una etiqueta de texto mediante una clase denominada TextView .
Al crear una instancia de la clase TextView , es necesario pasarle al constructor un determinado contexto de Android. Un contexto representa una especie de manejador del sistema, que facilita la resolución de recursos, el acceso a bases de datos o la configuración de ciertas características de la aplicación. La clase Activity hereda de la clase Context , por lo que la clase HolaMundo también es un contexto válido en Android.

TextView tv = new TextView(this);

Código 7. Creación de un objeto TextView

Una vez creada la etiqueta de texto, para asignarle un valor simplemente se llama al método setText() con la cadena “Hola Mundo” como argumento.

tv.setText("Hola Mundo");

Código 8. Especificación del mensaje para el objeto TextView

Como paso final, deben vincularse los elementos visuales que se hayan creado (las “vistas”, como TextView ) con la pantalla que la aplicación mostrará al usuario. Este paso se realiza mediante el método setContentView() de la clase Activity , que asigna una determinada vista indicando al sistema que es la que debe ser la mostrada por la pantalla.

setContentView(tv);

Código 9. Establecer la vista para el usuario

3.11.3 Ejecutar la aplicación

Antes de lanzar y probar la aplicación, debe crearse una configuración específica para la ejecución. En esta configuración se debe indicar el proyecto a ejecutar, la Activity que iniciará la ejecución, las opciones del emulador y otros valores opcionales.

1. Seleccione la pestaña Run > Run Configurations. Se abrirá una nueva ventana.
2. En el panel de la izquierda, hay que localizar Android Application y pulsar el icono con la leyenda New launch configuration.
3. Asignar un nombre para esta configuración. Por ejemplo, “Hola Mundo Conf”.
4. En la etiqueta Android, pulsar el botón Browse para localizar el proyecto “HolaMundo” y seleccionar la opción Launch para localizar la actividad “com.android.hola.HolaMundo”.
5. Pulsar el botón Run.

Esto lanzará el emulador de Android. La primera vez que se lanza, puede tardar unos segundos en arrancar. Es recomendable no cerrar el emulador mientras se esté editando y probando un proyecto, para evitar así tener que repetir siempre el proceso de carga.
Si se muestra un error parecido a “Cannot create data directory”, es necesario acudir a Run Configurations > pestaña Target, y buscar el campo Additional Emulator Command Line Optiones. En dicho campo, introducir la orden “-datadir C:\” si, por ejemplo, se desea crear los ficheros imagen del emulador en el directorio C:\. La apariencia del emulador debe ser algo similar a la Figura 12:

Aplicaciones Android
Figura 12. Ejecución en el emulador de “Hola Mundo”

3.12 Contenido de un proyecto Android

Al crear un proyecto Android, en el workspace de Eclipse se genera una nueva carpeta con el nombre de dicho proyecto. Esta carpeta contiene una serie de subcarpetas y de ficheros que constituyen la anatomía completa de un proyecto Android. En este apartado se intentará dar una visión general del significado y cometido de cada uno de estos elementos.
Volviendo al ejemplo “Hola Mundo”, si se echa un vistazo al workspace se podrá observar una jerarquía similar a la mostrada en la Figura 13:

Aplicaciones Android
Figura 13. Jerarquía en el workspace de Eclipse

Las carpetas y ficheros de “HolaMundo” han sido creadas por el plug-in ADT, y sus características dependerán siempre del tipo de proyecto que se esté construyendo. Los principales elementos que podemos encontrar se describen a continuación.

3.12.1 Carpeta \src

Carpeta que contiene los archivos fuente .java del proyecto. Utiliza la misma jerarquía de carpetas que la indicada por el nombre del paquete que se haya asignado. Por ejemplo, en el caso de la aplicación “HolaMundo” se especificó el nombre de paquete “com.android.hola”, por lo que se podrá encontrar la siguiente jerarquía:

Aplicaciones Android
Figura 14. Jerarquía de la carpeta “src”

La última carpeta tiene los ficheros fuente en java. El primero de ellos, “HolaMundo.java”, aloja la única clase que se creó para la aplicación; el segundo fichero, “R.java”, es un archivo que siempre se adjunta por defecto a cualquier proyecto Android y que declara una serie de índices o referencias a los recursos externos que se utilizan en el proyecto actual.

3.12.2 Carpeta \res

La carpeta “\res” alberga los recursos utilizados en el proyecto. Por recurso se entiende cualquier fichero externo que contenga datos o descripciones referentes a la aplicación, y que debe ser compilado junto a los ficheros fuente. Esta compilación permite al recurso ser accedido de forma más rápida y eficiente.
Android contempla muchos tipos de recursos, como XML, JPEG o PNG, entre otros. En la mayoría de los casos, un recurso constituye (o viene acompañado de) un fichero XML que lo describe y/o configura. Por ejemplo, un caso típico de recurso en Android son las traducciones de una aplicación a distintos idiomas. A pesar de ser cadenas de texto, se representan como recurso a través de un documento XML.
Cada uno de los recursos utilizados en una aplicación para Android ha de estar localizado en la carpeta adecuada, en función de su naturaleza. De esta forma, dentro de la carpeta de recursos “\res” se pueden encontrar las siguientes subcarpetas:

- \anim : aquí se ubican aquellos ficheros XML que describen una animación para un determinado elemento. Las animaciones son movimientos y efectos gráficos básicos.
- \drawable : esta carpeta contiene recursos que pueden ser dibujados en la pantalla. Por ejemplo, imágenes con formato JPG, PING o GIF. - \layout : que contiene layouts o diseños que pueden ser usadas para construir interfaces. Un diseño, que representa la pantalla completa o simplemente una parte, se describe a través de un fichero XML. - \values : esta carpeta tendrá ficheros XML que declaran valores de diferentes tipos. Por ejemplo, cadenas de texto, colores predefinidos, arrays de elementos, dimensiones, estilos, etc. En cierta medida, los recursos aquí localizados pueden verse como declaraciones de variables que serán accedidas después desde el código. Por convención, existirá dentro de esta carpeta un fichero XML por cada tipo distinto de recurso que se declare: “strings.xml” para los strings, “colors.xml” para los colores, “dimens.xml” para las dimensiones, “integers.xml” para los valores enteros, etc. - \xml : donde se ubican aquellos ficheros XML genéricos que pueden ser procesados como tales desde el código (es decir, utilizando un parseador de XML). - \raw : en esta carpeta se incluyen aquellos recursos que son añadidos a la compilación directamente sin procesar, de forma que la aplicación podrá leerlos como flujos de bytes. Un recurso típico de esta carpeta son los archivos de audio.

Aplicaciones Android
Figura 15. Jerarquía de la carpeta “res”

Todos los recursos que aquí se declaren quedarán reflejados en el fichero fuente “R.java”. Este fichero se genera y sincroniza de forma automática en tiempo de compilación según el contenido de la carpeta “\res”, por lo que está completamente desaconsejado realizar manualmente cualquier tipo de cambio. Puede forzarse la sincronización en Eclipse utilizando la opción Refresh del proyecto. El fichero “R.java” contendrá una subclase por cada tipo distinto de recurso que se haya declarado. A su vez, estas subclases declaran una serie de identificadores que representan, uno por uno, cada uno de los de recursos declarados de ese tipo concreto.
Gracias a este fichero, los recursos se pueden utilizar y referenciar directamente en el código de la aplicación, como si de variables globales se trataran. Existen varios mecanismos para invocar estos recursos en el código de la aplicación, pero el más genérico de ellos es mediante el método getResources() de la clase Context .

3.12.3 Carpeta \bin

Esta carpeta contiene los archivos binarios del proyecto generados a partir de los archivos fuente. Al igual que la carpeta “\src", se mantiene la misma jerarquía de subcarpetas que la representada en el nombre del paquete.

3.12.4 Archivo AndroidManifest.xml

Un elemento imprescindible en cualquier aplicación para Android es el archivo denominado “AndroidManifest.xml”. Este archivo, generado de forma automática por el plug-in de Eclipse, representa un manifiesto escrito en XML que describe de forma genérica cada uno de los componentes que forman la aplicación (a saber: Activity, Broadcast Intent Receiver, Service y Content Provider). Esta descripción abarca aspectos como sus capacidades y requisitos, las clases que los implementan, los datos que pueden manejar o cuándo deben ser lanzados. En este fichero también pueden concretarse permisos y políticas de seguridad que afectan a toda la aplicación.

Formato del manifiesto

La estructura que ha de tener este importante documento se muestra a continuación a través de un básico DTD. No se han incluido en él los atributos que pueden llevar algunos elementos, ya que excedería el objetivo ilustrativo que persigue, pero sí se indica su cardinalidad:

< !ELEMENT manifest
(uses-permission*, permission*, instrumentation*, application?)>
< !ELEMENT application
(activity+, receiver*, service*, provider*)>
< !ELEMENT activity
(intent-filter*, metadata*)>
< !ELEMENT receiver
(intent-filter*, metadata*)>
< !ELEMENT service
(intent-filter*, metadata*)>
< !ELEMENT provider
(metadata*)>
< !ELEMENT intent-filter
(action+, category+, data*)>

Código 10. DTD reducido de un fichero “AndroidManifest.xml”

Los elementos XML que se pueden encontrar en la declaración del manifiesto se describen en las siguientes líneas:

- < manifest> : el nodo raíz, bajo el cuál se declararán todos los contenidos del manifiesto.
- < uses-permission> : declara requisitos de seguridad para que el paquete pueda ser desplegado correctamente.
- < permission> : define permisos utilizados para restringir a los componentes de esta aplicación el acceso a ciertos servicios de Android.
- < instrumentation> :
- < application> : elemento raíz que enumera, uno por uno, los componentes básicos que constituyen la presente aplicación. Contempla muchos atributos que matizan su configuración.
- < activity> : representa un componente Activity presente en la aplicación, encargado de representar una acción concreta y generalmente asociado a una interfaz de usuario. Deberá haber tantos elementos como componentes Activity haya en la aplicación.
- < intent-filter> : declara lo que se denomina un Intent Filter, encargado de describir cuándo y dónde puede ejecutarse la Activity de la que pende. Mediante este elemento se especifica qué acciones puede manejar la presente actividad, es decir, qué elemento Intent puede atender. Permite además la inclusión de varios atributos que matizan su funcionamiento.
- < action> : acción soportada por la Activity.
- < category> : categoría de la Activity.
- < data> : datos aceptados por la Activity.
- < meta-data> : metadatos sobre la Activity definidos por el desarrollador.
- < receiver> : elemento que representa a un componente Broadcast Intent Receiver, cuya misión es lanzar una acción en respuesta a un evento. Deberá haber tantos elementos declarados como componentes Broadcast Intent Receiver haya en la aplicación.
- < service> : este elemento se corresponde con un componente Service presente en la aplicación, encargado de ejecutar una acción en background. Deberán aparecer tantos elementos como componentes Service haya en la aplicación.
- < provider> : elemento que encarna a un componente Content Provider, utilizado en la aplicación para almacenar y compartir datos. Debería haber tantos elementos declarados como componentes Content Provider haya en la aplicación.

Un elemento especialmente interesante dentro del fichero “AndroidManifest.xml” y que merece la pena extender un poco más es . Tal y como se expone en el listado anterior, este elemento especifica cuándo y dónde puede ejecutarse una determinada Activity.
En Android, cuando una aplicación está ejecutándose, quiere realizar una determinada acción y necesita para ello algún componente externo entre los disponibles (como, por ejemplo, abrir una página web o utilizar un visor de imágenes) lanza lo que se denomina un Intent. Este elemento contiene información sobre quién desea hacer algo, qué desea hacer y cómo desea hacerlo. Es entonces cuando Android utiliza los Intent Filter declarados en los “AndroidManifest.xml” para filtrar y decidir: compara en cada uno de ellos el valor del elemento y averigua qué aplicación es la más óptima para hacerse cargo de la acción requerida.

Manifiesto de “Hola Mundo”

En el ejemplo anteriormente visto, “Hola Mundo”, se puede encontrar el siguiente “AndroidManifest.xml”, generado de forma automática por el plug-in de Eclipse:

< ?xml version="1.0" encoding="utf-8"?>
< manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.android.hola">
< application android:icon="@drawable/icon"
android:label="@string/app_name">
< activity android:name=".HolaMundo" android:label="@string/app_name">
< intent-filter>
< action android:name="android.intent.action.MAIN" />
< category android:name="android.intent.category.LAUNCHER" />
< /intent-filter>
< /activity>
< /application>
< /manifest>

Código 11. Manifiesto del ejemplo “Hola Mundo”

En este manifiesto, primero se declara el documento como un XML válido y se adjunta un espacio de nombres adecuado en el elemento , así como el paquete al que pertenece con el atributo package .
A continuación, existe un elemento que se dispone a declarar los componentes que forman la aplicación completa. Recuérdese que solamente puede haber un único elemento por manifiesto. El atributo android:icon indica que existe un recurso del tipo “drawable”, ubicado en la carpeta HolaMundo\res\drawable y de nombre “icon”, que debe ser usado como el icono representativo de esta aplicación. Además, el atributo android:label señala que existe también un recurso, de tipo string y con nombre “app_name”, que será la etiqueta de texto visible para el usuario. Este recurso se encontrará ubicado en la carpeta HolaMundo\res\values, dentro del fichero “strings.xml”.
Dentro del elemento se declara el único componente que constituye la aplicación, un componente Activity. El elemento declara un atributo androide:name que especifica el nombre de la clase que implementa dicha Activity, así como la misma etiqueta de texto “app_name” para darle un nombre visible, a través del atributo android:label .
Por último, la Activity declarada lleva asociado un Intent Filter, que anuncia cómo y cuándo debe ser lanzada dicha actividad. El elemento define, mediante los elementos y , que la presente actividad ha de ser considerada la clase principal de la aplicación ( android.intent.action.MAIN ) y que se ha de ejecutar cuando el usuario quiera lanzar la aplicación “Hola Mundo” ( android.intent.category.LAUNCHER ).

3.13 Definición de interfaces de usuario con XML

En el ejemplo de “Hola Mundo”, se crea una sencilla interfaz consistente únicamente en una ventana con un título desde la que se imprime un mensaje. Esta interfaz está embebida en el propio código fuente; en casos tan sencillos como éste, cambiar la interfaz para ampliarla o sencillamente para darle un aspecto completamente nuevo a nuestra aplicación sería tarea fácil.
Sin embargo, piénsese ahora en aplicaciones para Android mucho más complejas, con cientos o miles de líneas de código fuente dedicadas únicamente a la interfaces de usuario que pueda tener. Este código acaba siempre vinculándose en exceso al resto de código fuente ajeno a la interfaz, provocando que ligeros cambios de interfaz signifiquen muchas horas de trabajo en cambios y nuevos diseños del código completo. Por ello, Android contempla una forma más sencilla, y sobre todo independiente, de configurar interfaces de usuario sin tener que afectar apenas al código fuente de la aplicación.
El método alternativo para construir interfaces en Android consiste en utilizar ficheros escritos en XML y configurar en ellos los aspectos relacionados con esas interfaces. El fichero XML resultante se vincula al proyecto simplemente ubicándolo en la carpeta de recursos “\res\layout” y referenciándolo brevemente en el código fuente.
Por ejemplo, una forma de utilizar XML para crear la misma interfaz de usuario que ya se tenía en “Hola Mundo” sería la siguiente:

< ?xml version="1.0" encoding="utf-8"?>
< TextView xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:text="Hello, Android"/>

Código 12. Ejemplo de interfaz con XML

El formato del fichero es muy simple: consiste en construir un árbol de elementos, de tal forma que cada elemento se corresponda con el nombre de una clase View válida (como TextView ) y utilizar los atributos y la anidación de elementos para configurar el tipo de interfaz que se desee.
En el Código 12 se puede comprobar como se define, en primer lugar, el documento XML como un documento válido. A continuación, se indica un único elemento < TextView> , que se corresponde con la clase TextView utilizada ya anteriormente. Observamos los siguientes atributos:

- xmlns:android : declara el espacio de nombres Android válido.
- android:layout_width : indica qué cantidad del ancho de la pantalla ha de ser ocupado por este elemento View. En este caso, se declara que la caja de texto ocupe toda la pantalla.
- android:layout_height : declara qué cantidad del alto de la pantalla va a ocupar el elemento View al que hace referencia. Al igual que antes, en este caso se desea que ocupe todo el alto de la pantalla.
- android:text : simplemente indica el texto que se desea mostrar en este elemento View.

Para comprobar su funcionamiento, se deben realizar dos pasos:

1. Sustituir el contenido del fichero “main.xml” presente en la carpeta “\res\layout”, por el XML presente en el Código 12.
2. Cambiar el fichero fuente “HolaMundo.java” para que tenga contenido mostrado en el Código 13:

package com.android.hola;
import android.app.Activity;
import android.os.Bundle;
public class HolaMundo extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}

Código 13. Código fuente de “Hola Mundo” usando interfaz en XML

El único cambio presente en “HolaMundo.java” es la eliminación de las referencias a la clase TextView , sustituyéndolas por una única llamada a setContentView() . Este método accede al diseño o layout llamado “main” presente en el fichero de recursos “R.java”. En este, como se recordará, quedan declarados de forma completamente automática, y sin intervención del desarrollador, todos los tipos de recursos existentes en la carpeta “\res”.
Más adelante, en esta misma memoria, se detallarán los aspectos concernientes a la construcción de interfaces de usuario más complejas utilizando declaraciones en formato XML.



Beneficiese adquiriendo software original.