• Author / Uploaded
• redsony1422

• Categories
• Eclipse (software)
• Android (sistema operativo)
• Entorno de desarrollo integrado
• Java (lenguaje de programación)
• Kernel (sistema operativo)

Citation preview

INTRODUCCIÓN

ÍNDICE 1.1

INTRODUCCIÓN .............................................................. 3 1.1.1 Qué es Android .................................................................3 1.1.2 Proyecto libre (Open Source) ..........................................3 1.1.3 Su historia ..........................................................................3 1.1.4 Inconvenientes de Android..............................................4

1.2

QUÉ ES ECLIPSE ............................................................. 5 1.2.1 El Consorcio Eclipse ........................................................5 1.2.2 Instalación de Java Developmente Kit (JDK)................6 1.2.3 Instalación de Eclipse ......................................................7 1.2.4 Instalación de las librerías de Android...........................9 1.2.5 Añadir versiones y componentes de Android ............19 1.2.6 Definición del dispositivo virtual de Android ..............25

2

Introducción

1.1

INTRODUCCIÓN

1.1.1 Qué es Android Android es un sistema operativo, inicialmente diseñado para teléfonos móviles como los sistemas operativos iOS (Apple), Symbian (Nokia) y Blackberry OS. En la actualidad, este sistema operativo se instala no sólo en móviles, sino también en múltiples dispositivos, como tabletas, GPS, televisores, discos duros multimedia, mini ordenadores, etcétera. Incluso se ha instalado en microondas y lavadoras. Está basado en Linux, que es un núcleo de sistema operativo libre, gratuito y multiplataforma. Este sistema operativo permite programar aplicaciones empleando una variación de Java llamada Dalvik, y proporciona todas las interfaces necesarias para desarrollar fácilmente aplicaciones que acceden a las funciones del teléfono (como el GPS, las llamadas, la agenda, etcétera) utilizando el lenguaje de programación Java. Su sencillez principalmente, junto a la existencia de herramientas de programación gratuitas, es la causa de que existan cientos de miles de aplicaciones disponibles, que extienden la funcionalidad de los dispositivos y mejoran la experiencia del usuario.

1.1.2 Proyecto libre (Open Source) Una de las características más importantes de este sistema operativo reside en que es completamente libre. Es decir, ni para programar en este sistema ni para incluirlo en un teléfono hay que pagar nada. Por esta razón, es muy popular entre los fabricantes de teléfonos y desarrolladores, ya que los costes para lanzar un teléfono o una aplicación son muy bajos. Cualquier programador puede descargarse el código fuente, inspeccionarlo, compilarlo e incluso modificarlo.

1.1.3 Su historia Android era un sistema operativo para móviles prácticamente desconocido hasta que en 2005 lo compró Google. En noviembre de 2007 se creó la Open Handset Alliance, que agrupó a muchos fabricantes de teléfonos móviles, procesadores y Google. Este año se lanzó la primera versión de Android, junto con el SDK (del inglés, Software Development Kit, que significa Kit del desarrollo de software) para que los programadores empezaran a crear sus aplicaciones para este sistema operativo.

3

El despegue del sistema operativo fue lento porque se lanzó antes el sistema operativo que el primer terminal móvil, aunque rápidamente se ha colocado como el sistema operativo de móviles más vendido del mundo. En febrero de 2011 se anunció la versión 3.0 de Android, cuyo nombre en clave es Honeycomb, que está optimizada para tabletas en lugar de para teléfonos móviles.

Versiones disponibles: Las versiones de Android reciben nombre de postres en inglés. En cada versión el postre elegido empieza por una letra distinta siguiendo un orden alfabético:

C: D: E: F: G: H: I: J:

Cupcake (v1.5), magdalena glaseada. Donut (v1.6), rosquilla. Éclair (v2.0/v2.1), pastel francés conocido en España como pepito. Froyo (v2.2), (abreviatura de «frozen yogurt») yogur helado. Gingerbread (v2.3), pan de jengibre. Honeycomb (v3.0/v3.1), panal. IceCream Sandwich (4.0), sandwich de helado. Jelly Bean (¿¿??), gomitas de gelatina)

En el siguiente enlace puedes encontrar una descripción de la funcionalidad que incluye cada versión de Android.

1.1.4 Inconvenientes de Android Android ha sido criticado muchas veces por la fragmentación que sufren sus terminales (con versiones distintas de Android), ya que las actualizaciones no se despliegan automáticamente en estos terminales una vez que Google lanza una nueva versión. Cada fabricante debe crear su propia versión. Sin embargo, esa situación cambiará ya que los fabricantes se han comprometido a aplicar actualizaciones al menos durante los 18 meses siguientes desde que empiezan a vender un terminal en el mercado. Además, actualmente Google tiene la intención de unificar la funcionalidad entre las versiones del sistema operativo para tabletas y móviles en la versión 4.0. Disponer del código fuente del sistema operativo no significa que se pueda tener siempre la última versión de Android en un determinado móvil, ya que el código para soportar el hardware de cada fabricante normalmente no es público; así que faltaría un trozo básico del firmware (controladores) para poder hacerlo funcionar en dicho terminal. Hay que tener en cuenta que las nuevas versiones de Android suelen requerir más recursos, por lo que, en los modelos más antiguos, no se puede instalar la última versión por insuficiente memoria RAM, velocidad de procesador, etcétera. 4

Introducción

1.2

QUÉ ES ECLIPSE

Eclipse es un entorno de software multi-lenguaje de programación que incluye un entorno de desarrollo integrado (IDE). Inicialmente, se diseñó pensando principalmente en el lenguaje de programación Java y se puede utilizar para desarrollar aplicaciones en este lenguaje. En la web oficial de Eclipse (www.eclipse.org), se define como “An IDE for everything and nothing in particular” (un IDE para todo y para nada en particular). Eclipse es, en realidad, un armazón (workbench) sobre el que se pueden instalar herramientas de desarrollo para cualquier lenguaje, mediante la implementación de los plugins adecuados. El término plugin procede del inglés to plug, que significa enchufar. Es un software que permite cambiar, mejorar o agregar funcionalidades. La arquitectura de plugins de Eclipse permite, además de integrar diversos lenguajes sobre un mismo IDE, introducir otras aplicaciones accesorias que pueden resultar útiles durante el proceso de desarrollo, tales como herramientas UML (modelado de objetos), editores visuales de interfaces, ayuda en línea para librerías, etcétera. Usando distintas librerías es posible servirse de este entorno de desarrollo para otros lenguajes de programación, como Ada, C, C + +, COBOL, Perl, Delphi, PHP, Python, R. Ruby, Scala, Clojure y Scheme. A menudo el IDE Eclipse añade un apellido a su nombre cuando se usa para programar otro lenguaje. Por ejemplo, se llama Eclipse ADT (Ada Development Toolkit) para Ada, Eclipse CDT para C / C + +, Eclipse JDT para Java y Eclipse PDT para PHP. Esta lista de lenguajes aumenta con los años, ya que este IDE se está convirtiendo en el entorno de desarrollo de muchos programadores por su simplicidad y facilidad de uso.

1.2.1 El Consorcio Eclipse En su origen, el Proyecto Eclipse era un proyecto de desarrollo OpenSource, desarrollado y mantenido en su totalidad por IBM. Bajo la dirección de IBM, se fundó el Consorcio Eclipse, al cual se unieron algunas empresas importantes como Rational, HP o Borland. Desde el año 2004, el Consorcio Eclipse es independiente de IBM y entre otras empresas, está integrado por HP, QNX, IBM, Intel, SAP, Fujitsu, Hitachi, Novell, Oracle, Palm, Ericsson y RedHat, además de por algunas universidades e institutos tecnológicos.

5

1.2.2 Instalación de Java Developmente Kit (JDK) Es muy importante tener en cuenta que, para poder ejecutar el entorno de desarrollo Eclipse y las librerías de Android, es necesario tener instaladas en el ordenador las librerías de desarrollo de Java. Aunque ya está disponible la versión 1.7, para poder compilar aplicaciones Android, es necesario instalar la versión 6 de Java (también conocida como Java 1.6). Podemos descargar la versión correcta del JDK de Java en: http://java.sun.com/javase/downloads

6

Introducción

Nota: en el caso de Linux o Mac, es posible también instalar Java usando los programas habituales del sistema operativo que permiten la actualización de paquetes. Nota: si vas a instalar Eclipse y las librerías de Android en Linux, lee las notas que se encuentran en “Preguntas y Respuestas” de esta Introducción en la mesa del curso.

1.2.3 Instalación de Eclipse La instalación es muy sencilla. Simplemente accedemos a la página web: http://www.eclipse.org/downloads/

En esta página seleccionamos el tipo de Sistema Operativo donde vamos a instalar Eclipse y descargamos el archivo "Eclipse Classic 3.7".

7

Hay que tener en cuenta que debemos descargar la versión 32 bits o 64 bits en función del sistema operativo de que dispongamos. En el caso de Windows podemos ver el tipo de sistema operativo haciendo clic con el botón derecho del ratón en el icono "Equipo" o Mi PC del Escritorio y haciendo clic de nuevo en "Propiedades":

En el caso de Linux, desde la línea de comandos podemos ejecutar el siguiente comando para saber si el sistema operativo es de 64bits:

$ uname -m x86_64

En el caso de Apple Mac, utiliza el Perfil de Sistema para determinar si estás utilizando un kernel de 64 bits.

1. En el menú Apple ( "Más información":

8

), selecciona Acerca de este Mac y a continuación, haz clic en

Introducción

2. En el panel "Contenido", selecciona "Software". 3. Si Extensiones y kernel de 64 bits está configurada como Sí, estás utilizando un kernel de 64 bits.

Cuando hayamos descargado el fichero correspondiente, lo copiamos a un directorio o carpeta del ordenador y descomprimimos este fichero. Es recomendable usar un directorio sencillo que podamos recordar fácilmente, por ejemplo C:\cursos_Mentor\eclipse. Además, es muy importante que los nombres de los directorios no contengan espacios, pues Eclipse puede mostrar errores y no funcionar correctamente. Una vez descomprimido el fichero, Eclipse está listo para ser utilizado; no es necesario hacer ninguna operación adicional. Recomendamos hacer un acceso directo en el Escritorio del ordenador para arrancar rápidamente el entorno de programación Eclipse.

1.2.4 Instalación de las librerías de Android A continuación, debemos instalar el Paquete de Desarrollo de iniciación (en inglés, SDK Starter Package) de Android. Este paquete no incluye las librerías de desarrollo completas, sino que únicamente es el núcleo del SDK que se utiliza para descargar el resto de los componentes SDK, como la última plataforma Android. 9

Para descargar el fichero necesario, accedemos a la página de descarga del SDK de Android y nos bajamos la versión que corresponda en función del sistema operativo donde vayamos a instalarlo. Recomendamos que hay que descargar el archivo .zip, ya que con éste la instalación es más sencilla y rápida:

Cuando hayas descargado la versión .zip o .tgz, descomprímelo en el disco duro. Recomendamos que conviene usar el directorio C:\cursos_Mentor\Android\android-sdkwindows. Si usas otro directorio, toma nota del mismo, ya que, más adelante, tendrás que usar el nombre de este directorio para acabar de configurar el plugin de Android en Eclipse. Ahora vamos a instalar las librerías necesarias en Eclipse. Estas librerías se denominan Android Development Tools (ADT). Para ello, arrancamos Eclipse haciendo doble clic sobre el acceso directo que hemos creado anteriormente. A continuación, Eclipse pedirá que seleccionemos el "workspace", es decir, el directorio donde queremos guardar los proyectos.

10

Introducción

Seleccionaremos un directorio sencillo y fácil de recordar. Importante: Recomendamos usar el directorio C:\cursos_Mentor\Android\proyectos como carpeta personal

Finalmente hacemos clic en OK para abrir Eclipse:

Ahora vamos a configurar las preferencias de la versión de Java en Eclipse para compilar los proyectos de Android. Para ello, hacemos clic en la opción del menú “Window-> Preferences...”, hacemos clic en el panel izquierdo sobre “Java->Installed JREs” y seleccionamos “jre6” en el campo “Installed JREs”:

Si no podemos seleccionar "jre6" debemos usar el botón "Add" para añadir las librerías del JRE 6. Por ejemplo, en Windows, se pueden encontrar en el directorio: "C:\Program Files\Java\jre6". 11

Para finalizar, en esta ventana hay que seleccionar la versión de Java utilizada para compilar los proyectos de Android. Para ello hacemos clic en “Java->Compiler” y elegimos “1.6” en el campo “Compiler compliance settings”:

Si no hemos seleccionado la versión 6 de JRE en el paso anterior aparecerá el siguiente mensaje de error en Eclipse:

12

Introducción

Importante: Es necesario disponer de conexión a Internet para poder continuar con los siguientes pasos y poder descargar las librerías necesarias.

A continuación, seleccionamos en el menú Help -> Install New Software... En el cuadro de diálogo que aparecerá, introducimos la dirección del sitio de descarga de las librerías ADT: https://dl-ssl.google.com/android/eclipse/ Y pulsamos la tecla Intro. A continuación, marcamos todas las opciones tal y como se muestra en la siguiente captura de pantalla:

Es muy Importante comprobar la versión de Java. Si no, no se instalará bien el software de Android.

13

Hacemos clic en el botón "Next". Nota: este proceso puede llevar un rato en función de la conexión a Internet y de la potencia del ordenador que tengamos. Después, aparecerá la siguiente ventana:

Hacemos clic de nuevo en "Next", seleccionamos "I accept..." en el acuerdo de licencia y hacemos clic en "Finish":

14

Introducción

A continuación, se instalará el software necesario de Android:

Se mostrará este aviso de seguridad y pulsaremos en "OK" para continuar la instalación:

Al acabar la instalación, es necesario reiniciar Eclipse. Para ello haremos clic en "Restart":

15

Al arrancar de nuevo Eclipse ya dispondremos de las librerías necesarias para empezar a trabajar con Android:

Podemos hacer clic en la X de la pestaña "Welcome" para acceder al entorno de desarrollo:

La primera vez que accedemos al entorno Eclipse, aparece la siguiente ventana en la que debemos indicar dónde hemos instalado el SDK de Android:

16

Introducción

Hacemos clic en el botón “Browse...” e indicamos el directorio donde hemos instalado el SDK de Android. Si has seguido las instrucciones de Windows, el directorio por recomendado

para

descomprimir

el

archivo

del

SDK

es

“C:\cursos_Mentor\Android\android-sdk-windows”. Pulsamos el botón “OK” para finalizar la configuración.

A continuación, aparece otra ventana solicitando nuestra conformidad para enviar estadísticas de uso del SDK de Android. No es necesario hacerlo si no lo deseamos: 17

Pulsamos el botón “Finish” para finalizar la configuración. A continuación, aparece el siguiente mensaje indicando que no hemos instalado ninguna versión del sistema operativo Android:

Pulsamos el botón “OK”, en el siguiente paso, instalamos la versión de Android sobre la que vamos a trabajar en este curso. En el caso de que no aparezca la ventana que permite indicar a Eclipse dónde se encuentra el SDK de Android, podemos hacerlo manualmente. Para ello, hacemos clic en la opción del menú “Window-> Preferences...” izquierdo:

18

y seleccionamos “Android” en el panel

Introducción

Para acabar, pulsamos el botón “OK”.

1.2.5 Añadir versiones y componentes de Android El último paso en la configuración de las librerías de Android es descargar e instalar los componentes esenciales del SDK para el entorno de desarrollo. El SDK utiliza una estructura modular que separa las distintas versiones de Android, complementos, herramientas, ejemplos y la documentación en un único paquete que se puede instalar por separado. Para desarrollar una aplicación en Android, es necesario descargar, al menos, una versión. En este curso vamos a usar la versión 2.3, por ser la más extendida en el momento de redacción de la documentación. No obstante, vamos a emplear sentencias compatibles y recompilables en otras versiones. Para añadir esta versión hay que hacer clic en la opción “Android SDK Manager” del menú principal “Window” de Eclipse:

19

Se abrirá la ventana siguiente:

Para instalar la versión 2.3.3, seleccionamos los paquetes que se muestran en la siguiente ventana:

20

Introducción

Nota: la revisión de las versiones de Android puede ser superior cuando al alumno o alumna instale el SDK. Una vez hemos pulsado el botón “Install 6 packages”, aparece esta ventana y seleccionamos la opción “Accept All” y, después, hacemos clic en “Install”:

El instalador tarda un rato (10-20 minutos) en descargar e instalar los paquetes: 21

Para acabar, reiniciamos el ADB (Android Debug Bridge):

La instalación ha finalizado correctamente:

Ahora vamos a ver la estructura que tiene el SDK de Android. Para ello, abrimos el explorador en el directorio “C:\cursos_Mentor\Android\android-sdk-windows” o en el directorio donde lo hayamos descomprimido. La siguiente tabla describe los subdiretorios que contiene esta carpeta:

22

Introducción

NOMBRE CARPETA

DESCRIPCIÓN

add-ons/

Contiene los paquetes “add-on” del SDK de Android que permiten desarrollar aplicaciones usando librerías externas disponibles para algunos dispositivos o terminales.

docs/

Documentación completa en formato HTML, incluyendo la Guía del desarrollador y la guía de la API. Para leer la documentación, puedes abrir el fichero offline.html en un navegador Web.

platformtools/

Contiene las herramientas de desarrollo comunes del SDK que se actualizan con cada nueva versión de Android, tales como el ADB (Android Debug Bridge), así como otras herramientas que no se suelen utilizar directamente.

platforms/

Contiene las versiones de Android con las que se puede desarrollar aplicaciones en Eclipse. Cada versión se encuentra en un directorio independiente.

Directorio de la plataforma de la versión correspondiente, por ejemplo, "Android-10". Todos los directorios de la versión de Android contienen un / conjunto similar de archivos y la misma estructura de subdirectorios. Además, también incluye la librería de Android (android.jar) que se utiliza para compilar aplicaciones con esta versión de Android.

samples/

Contiene los ejemplos de código para esa versión específica de Android.

tools/

Contiene el conjunto de herramientas de desarrollo y creación de perfiles que son independientes de la versión de Android, como el emulador, el SDK de Android y AVD Manager, DDMS (Dalvik Debug Monitor Server), etcétera.

SDK Readme.txt

Archivo que explica cómo realizar la configuración inicial del SDK de Android.

SDK Manager.exe

Aplicación que inicia el SDK de Android y la herramienta AVD de gestión de paquetes. Sólo disponible en Windows.

23

Finalmente, vamos a incluir el directorio donde hemos instalado las librerías de Android en el PATH del sistema operativo. En concreto, vamos a incluir los directorios tools y platform-tools. Si has usado el directorio recomendado, los subdirectorios son: C:\cursos_Mentor\Android\android-sdk-windows\tools y C:\cursos_Mentor\Android\android-sdk-windows\platform-tools En Windows, se puede hacer esto accediendo al “Panel de control”, haciendo clic en el icono “Sistema”, seleccionando la pestaña “Opciones avanzadas” y haciendo clic en el botón “Variables de entorno”. A continuación, añadiremos los directorios anteriores a la variable PATH de la siguiente ventana:

En Windows 7 se puede acceder a la ventana anterior abriendo el “Panel de control”, haciendo clic en el icono “Sistema y Seguridad”, después en "Sistema" y, para acabar, en la opción "Configuración avanzada del sistema" para acceder a la ventana anterior:

24

Introducción

Escribiendo el comando path en una ventana de comandos de Windows podemos ver si se hemos modificado bien esta variable global del sistema:

Nota: en el resultado de este comando debemos ver el directorio de instalación de Android. Es muy importante que se muestre tal como aparece en la ventana anterior: con punto y coma al final del directorio SDK y sin espacios entre el punto y coma del directorio anterior. En OS X (Mac) y Linux, puedes agregar la ruta a la variable PATH con el comando SET o estableciendo la variable correspondiente en un script de inicio.

1.2.6 Definición del dispositivo virtual de Android Para poder hacer pruebas de las aplicaciones Android que desarrollemos sin necesidad de disponer de un teléfono Android, el SDK incluye la posibilidad de definir un Dispositivo Virtual de Android (en inglés, AVD, Android Virtual Device). Este dispositivo emula un terminal con Android instalado. Para definir el AVD, hacemos clic en la opción “Android AVD Manager” del menú principal “Window” de Eclipse:

25

Aparecerá la siguiente ventana:

Hacemos clic en el botón “New” de la ventana anterior y la completamos como se muestra en la siguiente ventana:

26

Introducción

La opción “Snapshot-> Enabled” permite guardar el estado del dispositivo de manera que todos los cambios que hagamos, como cambiar la configuración de Android o instalar aplicaciones, queden guardados. Así, la próxima vez que accedamos al emulador, se recupera automáticamente el último estado.

Importante: En el curso hemos creado un dispositivo virtual que no guarda el estado porque puede producir problemas de ejecución con Eclipse. En todo caso, el alumno o alumna puede usar la opción “Edit” del AVD cuando crea necesario que los últimos cambios sean almacenados para la siguiente sesión de trabajo

Para acabar, basta con hacer clic en “Create AVD”:

27

En esta Introducción puedes encontrar el vídeo “Cómo instalar Eclipse y el plugin Android”, que muestra de manera visual los pasos seguidos en las explicaciones anteriores

28

INTRODUCCIÓN AL ENTORNO ANDROID

ÍNDICE 1.1

INTRODUCCIÓN AL ENTORNO DE ANDROID ....................  31 1.1.1 Introducción ...................................................................................31 1.1.2 Características de Android...........................................................31 1.1.3 Arquitectura de Android ...............................................................33 1.1.4 Creación de un proyecto por líneas de comando ....................35

1.2

CONCEPTOS DE LAS APLICACIONES ANDROID ............... 37 1.2.1 Características de las aplicaciones Android.......................... 37 1.2.2 Componentes de las aplicaciones......................................... 37

1.3

CÓMO CREAR UN PROYECTO ANDROID ........................... 40 1.3.1 Un vistazo general al IDE de Eclipse ..................................... 40 1.3.1.1 Editores .................................................................................41 1.3.1.2 Vistas ................................................................................ …..41 1.3.1.3 Barras de Herramientas principal y secundarias ............43 1.3.1.4 Perspectivas .........................................................................43 1.3.2 Cómo crear un proyecto Android ...............................................46 1.3.2.1 Creación de un nuevo proyecto ........................................47 1.3.2.2 Nombre de la actividad .......................................................49 1.3.2.3 Descripción de los ficheros por defecto del proyecto....49 1.3.2.4 Ejecución del proyecto Android ........................................53 1.3.2.5 Cómo usar el emulador de Android (AVD) .......................56

1.4

CÓMO CREAR LA PRIMERA APLICACIÓN CON ANDROID63 1.4.1 Cambio en la Interfaz de usuario con Layout .........................66

1.5

DISEÑO DE LA INTERFAZ DE USUARIO .............................. 70 1.5.1 Cómo diseñar la interfaz de usuario mediante Vistas ..............70 1.5.2 Vistas disponibles de Android .....................................................71

2

Introducción al entorno Android

1.1

INTRODUCCIÓN AL ENTORNO DE ANDROID

1.1.1 Introducción En esta Unidad vamos a explicar las características y la arquitectura de Android. Además, describiremos el entorno de desarrollo Eclipse y crearemos nuestro primer proyecto Android. También, detallaremos los ficheros básicos que componen un proyecto Android. Finalmente, usaremos Paneles de diseño (Layout) y Componentes (View) para diseñar la interfaz de usuario en ejemplos de aplicaciones de Android.

1.1.2 Características de Android A continuación se muetra un resumen de las características más importantes:

Diseñado para dispositivo pequeños

El sistema operativo es compatible con pantallas VGA (y mayores), gráficos 2D y gráficos 3D presentes en muchos teléfonos tradicionales.

Almacenamiento

Dispone de la base de datos ligera SQLite donde se almacenan los datos de las aplicaciones.

Conectividad

Android soporta las siguientes tecnologías de conectividad: GSM/EDGE, IDEN, CDMA, EV-DO, UMTS, Bluetooth, Wi-Fi, LTE y WiMAX. Algunas son muy populares en los teléfonos actuales y otras se están desarrollando.

Mensajería

Se pueden usar tanto SMS como MMS.

Navegador web

El navegador web incluido en Android está basado en el motor del navegador de código abierto WebKit. Este navegador es muy eficiente y permite cargar las páginas Web rápidamente.

Soporte de Java

Aunque las aplicaciones se escriben en el lenguaje Java, no hay una Máquina Virtual de Java en el sistema operativo para ejecutar el código. Este código Java se compila en un ejecutable Dalvik y se ejecuta en la Máquina Virtual Dalvik. Dalvik es una máquina virtual especializada, diseñada específicamente para Android y optimizada para dispositivos móviles que funcionan con batería y que tienen memoria y procesador limitados. Es posible incluir las librerías J2ME nativas de Java mediante aplicaciones de terceros, como J2ME MIDP Runner. 31

Android soporta los siguientes formatos multimedia: WebM, H.263, H.264 (en 3GP o MP4), MPEG-4 SP, AMR, AMR-WB (en un contenedor Soporte multimedia 3GP), AAC, HE-AAC (en contenedores MP4 o 3GP), MP3, MIDI, Ogg Vorbis, WAV, JPEG, PNG, GIF y BMP.

Soporte para streaming (distribución en Internet)

Android soporta los siguientes formatos de streaming: RTP/RTSP, descarga progresiva de HTML (tag de HTML5). Adobe Flash Streaming (RTMP) es soportado mediante la instalación de Adobe Flash Player, pero sólo para algunos terminales.

Android puede manejar cámaras de fotos, de vídeo, pantallas táctiles, Soporte para GPS, acelerómetros, giroscopios, magnetómetros, sensores de hardware adicional proximidad y de presión, termómetro, aceleración 2D y 3D.

Entorno de desarrollo

El entorno de desarrollo es Eclipse 3.7 y el plugin de Herramientas de Desarrollo de Android (ADT) que incluye un emulador de dispositivos, herramientas de depuración y análisis de rendimiento.

Market (Mercado de aplicaciones)

El Android Market es un catálogo de aplicaciones gratuitas y de pago que pueden ser descargadas e instaladas desde los propios dispositivos Android.

Multi-táctil

Android tiene soporte nativo para pantallas multi-táctiles que permiten manejar la pantalla táctil con más de 1 dedo.

Bluetooth

En la versión 2.2 de Android se incluye la funcionalidad completa.

Videollamada

Android incluye la posibilidad de videollamada a través de Google Talk.

Multitarea

Existe la multitarea real de aplicaciones, es decir, las aplicaciones que no se están ejecutando en primer plano reciben ciclos de reloj del procesador para actualizar su estado.

Características basadas en voz

Es posible dar órdenes de voz al terminal. Por ejemplo, la búsqueda en Google a través de la voz ya estaba disponible desde la primera versión.

Android incluye la compartición de la conexión a Internet (en inglés, Tethering tethering), que permite usar el teléfono como un punto de acceso (compartición de inalámbrico, de manera que un ordenador puede usar la conexión 3G conexión a Internet) del móvil Android.

32

Introducción al entorno Android

1.1.3 Arquitectura de Android Los componentes principales de la arquitectura del sistema operativo Android son los siguientes:  Aplicaciones: todas las aplicaciones están escritas en lenguaje de programación Java. Las aplicaciones incluidas por defecto son un cliente de correo electrónico, programa de SMS, calendario, mapas, navegador, contactos, etcétera. Todas las aplicaciones de Android usan el siguiente conjunto de servicios y sistemas: o Un conjunto de componentes (Views) que se usan para crear las interfaces de usuario. Por ejemplo, botones, listas, tablas, cajas de texto, etcetera. o Proveedores de contenidos (Content Providers) que permiten a las aplicaciones acceder a la información de otras aplicaciones (por ejemplo, los Contactos del teléfono) o compartir datos entre ellas. o Gestor de recursos (Resource Manager), que permite acceder a recursos que no sean del código fuente, tales como textos de internacionalización, imágenes y ficheros de estilos (layout). o Gestor de notificaciones (Notification Manager), que permite

a todas las

aplicaciones mostrar alertas en la barra de estado de Android. o Gestor de actividades (Activity Manager), que controla el ciclo de vida de la aplicación.  Marco de desarrollo de aplicaciones: los programadores tienen acceso completo a las mismas APIs (librerías) del Framework (marco de desarrollo) utilizadas por las aplicaciones base. La arquitectura está diseñada para simplificar la reutilización de componentes, es decir, cualquier aplicación puede publicar sus capacidades y cualquier otra aplicación puede hacer uso de estas capacidades.  Librerías: Android incluye también un conjunto de librerías de C/C++ usadas por varios componentes del sistema. Entre ellas, se encuentran: System C library (implementación de la librería C estándar), librerías de medios, bibliotecas de gráficos, 3D y SQLite, entre otras. El programador puede hacer uso de estas librerías.  Runtime (ejecutable) de Android: Android también incluye un conjunto de librerías base que proporcionan la mayor parte de las funciones del lenguaje Java. Cada aplicación Android ejecuta un proceso con instancia individual de la máquina virtual Dalvik.  Núcleo Linux: Android está basado en Linux para los servicios base del sistema, como seguridad, gestión de memoria, procesos y controladores.

33

DIAGRAMA DE LA ARQUITECTURA ANDROID

La utilidad de línea de comandos genera automáticamente todos los archivos necesarios para crear un proyecto Android; incluso permite crear un proyecto para Eclipse.

Android usa Java como lenguaje base para el desarrollo de las aplicaciones. Por lo tanto, hace uso de los Paquetes Java (Package en inglés). Estos paquetes son contenedores de clases que permiten agrupar las distintas partes de un programa cuya funcionalidad tienen elementos comunes. El uso de paquetes proporciona las siguientes ventajas:

34

o

Agrupamiento de clases con características comunes

o

Reutilización de código

o

Mayor seguridad al existir niveles de acceso

Introducción al entorno Android

1.1.4 Creación de un proyecto por líneas de comando Usando la línea de comandos vamos a crear un proyecto Android. Es importante usar el directorio de trabajo que hemos creado anteriormente con Eclipse: C:\cursos_Mentor\Android\proyectos. Desde este directorio, debemos ejecutar el siguiente comando:

android create project --package es.mentor.eje1.unidad1.bienvenido --activity Bienvenido --target android-10 --path unidad1.eje1.bienvenido

para crear los ficheros básicos de un proyecto Android. Fíjate en qué la orden anterior es una única línea que debes ejecutar en la línea de comandos de tu sistema operativo.

C:\>cd C:\cursos_Mentor\Android\proyectos C:\cursos_Mentor\Android\proyectos> android create project --package es.mentor.unidad1.eje1.bienvenido --activity Bienvenido --target android-10 bienvenido

--path

Created project directory: C:\cursos_Mentor\Android\proyectos\bienvenido Created directory C:\cursos_Mentor\Android\proyectos\bienvenido\src\es\mentor\eje1\unidad1\bienvenido Added file C:\cursos_Mentor\Android\proyectos\bienvenido\src\es\mentor\eje1\unidad1\bienvenido\Bienv enido.java Created directory C:\cursos_Mentor\Android\proyectos\bienvenido\res Created directory C:\cursos_Mentor\Android\proyectos\bienvenido\bin Created directory C:\cursos_Mentor\Android\proyectos\bienvenido\libs Created directory C:\cursos_Mentor\Android\proyectos\bienvenido\res\values Added file C:\cursos_Mentor\Android\proyectos\bienvenido\res\values\strings.xml Created directory C:\cursos_Mentor\Android\proyectos\bienvenido\res\layout Added file C:\cursos_Mentor\Android\proyectos\bienvenido\res\layout\main.xml Created directory C:\cursos_Mentor\Android\proyectos\bienvenido\res\drawable-hdpi Created directory C:\cursos_Mentor\Android\proyectos\bienvenido\res\drawable-mdpi Created directory C:\cursos_Mentor\Android\proyectos\bienvenido\res\drawable-ldpi Added file C:\cursos_Mentor\Android\proyectos\bienvenido\AndroidManifest.xml Added file C:\cursos_Mentor\Android\proyectos\bienvenido\build.xml Added file C:\cursos_Mentor\Android\proyectos\bienvenido\proguard.cfg C:\cursos_Mentor\Android\proyectos>

35

Ahora no vamos a examinar en detalle los ficheros que hemos creado y que conjuntamente forman el proyecto Android. En el siguiente apartado de esta Unidad los detallaremos con un ejemplo real en Eclipse.

Este script genera los siguientes directorios y archivos principales:  /src: en este directorio es donde se almacenan los archivos de código fuente Java (con extensión .java).  /assets: en este directorio se guardan los recursos que utiliza la aplicación.  /res: es el directorio principal de recursos (resources). Aquí guardaremos imágenes o archivos multimedia que utilice nuestra aplicación.  /res/drawable-Xdpi: son los directorios de recursos gráficos o imágenes que utilizará nuestra aplicación con los nombres drawable-hdpi, drawable-mdpi y drawable-ldpi; en ellos se almacenan las imágenes dependiendo de la densidad de puntos por pulgada que tenga el dispositivo en el que se ejecute la aplicación.  /res/layout: en Android hay que separar el código Java de la aplicación y la interfaz gráfica. En este directorio es donde colocaremos los archivos xml que definen las vistas que utilizará la aplicación.  /res/values: de igual forma que separamos el código Java y la interfaz gráfica, Android separa también las cadenas constantes de texto (Internacionalización de la aplicación), las matrices, la paleta de colores, etcétera.  AndroidManifest.xml: es el archivo de configuración de la aplicación en el que se define lo que puede hacer nuestra aplicación, es decir, en él informamos al sistema operativo de las capacidades que tiene esta aplicación. En este archivo también indicaremos las actividades o servicios que ejecutará nuestra aplicación y los permisos de seguridad especiales necesarios si va a acceder a recursos compartidos del sistema, como por ejemplo el acceso al listado de contactos, empleo del GPS o la posibilidad de enviar mensajes SMS.  default.properties: fichero de proyecto para Eclipse.  Nota: una vez analizado los ficheros básicos del proyecto, podríamos importarlo en Eclipse. No obstante, por simplificación, no lo vamos a hacer, pues es más sencillo crear un proyecto nuevo directamente desde Eclipse.

Así pues, borramos el directorio C:\cursos_Mentor\Android\proyectos\bienvenido, para crear este mismo proyecto desde Eclipse directamente.

36

Introducción al entorno Android

1.2

CONCEPTOS DE LAS APLICACIONES ANDROID

1.2.1 Características de las aplicaciones Android Las Aplicaciones Android se forman con uno o más de los siguientes componentes: actividades, servicios, proveedores de contenidos y receptores de mensajes. Cada componente tiene una funcionalidad diferente en la aplicación; incluso la aplicación puede activar cada uno de los componentes de forma individual; es más, otras aplicaciones también los pueden activar. El archivo de manifestación (manifest) indica todos los componentes que usa la aplicación; en él también deben declararse todos los requisitos necesarios de la misma como, por ejemplo, la versión mínima de Android, las configuración mínima de hardware, etcétera. El código que no es de la aplicación, como las imágenes, cadenas de internacionalización, diseño de la interfaz de usuario, otros recursos, etcétera, puede incluir distintas configuraciones en función del idioma del teléfono o diseños de la interfaz del usuario en función de los diferentes tamaños de pantalla. Las aplicaciones de Android están escritas en el lenguaje de programación Java. Las herramientas de SDK de Android compilan este código, junto con sus datos y los archivos de recursos, en un paquete Android. Este archivo tiene la extensión .apk y lo utiliza Android para instalar la aplicación. Una vez instalada una aplicación en un dispositivo, Android la aloja en su propia caja de arena (sandbox). Sandbox, palabra del inglés que significa caja de arena (Sand+box), es un sistema informático que aísla los procesos; de esta manera se pueden ejecutar aplicaciones de forma independiente. Se utiliza para evitar la corrupción de datos del sistema donde éstos se ejecutan. El sistema Android aplica el principio de “privilegios mínimos” (recuerda que Android se basa en el kernel de Linux). Es decir, cada aplicación, por defecto, sólo tiene acceso a los componentes que necesita para hacer su trabajo y nada más. Esto crea un entorno muy seguro en el que una aplicación no puede acceder a las partes de un sistema para las que no tiene permiso.

1.2.2 Componentes de las aplicaciones Los Componentes de las aplicaciones son los elementos esenciales de una aplicación Android. Cada componente es un punto diferente de entrada por el que el sistema operativo puede interaccionar con la aplicación. No todos los componentes son verdaderos puntos de entrada, sino que algunos dependen unos de otros, aunque cada uno exista como una entidad separada en Android y desempeñe un papel específico que define el comportamiento general de la aplicación. 37

Existen los siguientes tipos de componentes de la aplicación:

 Actividades (Activities): una actividad representa una pantalla única con una interfaz de usuario. Por ejemplo, una aplicación de correo electrónico puede tener una actividad que muestra una lista de correo electrónico nuevo, otra actividad que compone un correo y otra actividad que lee los mensajes. Aunque las actividades trabajan conjuntamente para dar la sensación de una única aplicación, cada una de ellas es independiente de las otras. Por lo tanto, otra aplicación externa diferente podría iniciar cualquiera de estas actividades (si la aplicación de correo electrónico lo permite). Por ejemplo, una aplicación que gestiona los contactos podría iniciar la actividad que compone nuevos mensajes de correo indicando como destinatario del mensaje al contacto seleccionado en la primera aplicación. Una actividad se implementa a partir de la clase Java Activity. Más adelante veremos cómo se usa. Puedes pensar en una actividad de Android como si fuera una ventana en una aplicación de escritorio o una página HTML en una aplicación Web. Android está diseñado para cargar muchas actividades pequeñas, por lo que se permite al usuario abrir nuevas actividades y pulsar el botón “Atrás” para ir a un estado anterior, al igual que se hace en un navegador web.  Servicios (Services): un servicio es un componente que se ejecuta en segundo plano y que realiza operaciones cada cierto tiempo. Un servicio no proporciona una interfaz gráfica al usuario. Por ejemplo, un servicio puede reproducir música en segundo plano mientras el usuario está en otra aplicación, o puede obtener información de Internet sin la interacción del usuario. Otros componentes, como una actividad, pueden iniciar un servicio e interactuar con él si es necesario. Un servicio se implementa a partir de la clase Java Service. Más adelante veremos cómo se usa.  Proveedores de contenidos (Content providers): un proveedor de contenidos maneja el conjunto de datos compartido de la aplicación. Puede almacenar información en el sistema de archivos, en una base de datos SQLite, en Internet o en cualquier otro lugar de almacenamiento permanente al que la aplicación tenga acceso. A través del proveedor de contenidos, otras aplicaciones pueden consultar e incluso modificar los datos (si el proveedor de contenidos lo permite). Por ejemplo, Android proporciona un proveedor de contenidos que gestiona la información de los contactos del teléfono. Por lo tanto, cualquier aplicación, con los permisos adecuados, puede hacer

una

consulta

al

proveedor

de

contenido

de

los

contactos

(ContactsContract.Data) para leer y escribir información sobre una persona en particular. 38

Introducción al entorno Android

Los proveedores de contenidos se utilizan también para escribir y leer datos que son privados de la aplicación y no se comparten. Por ejemplo, una aplicación de Notas puede utilizar un proveedor de contenidos para guardar las notas. Un proveedor de contenidos se implementa a partir de la clase ContentProvider y debe implementar un conjunto estándar de métodos (API) que permiten a otras aplicaciones interaccionar con él. Más adelante veremos cómo se usa.  Receptores de mensajes (Broadcast receivers): un receptor de mensajes responde a mensajes difundidos (broadcast) a todos los elementos del sistema. Por ejemplo, un mensaje puede anunciar que la pantalla se ha apagado, la batería está descargada o que se ha capturado una foto. Las aplicaciones también pueden emitir este tipo de mensajes para, por ejemplo, indicar a otras aplicaciones que ciertos datos ya han sido descargados en el dispositivo y están disponibles para ser utilizados. Aunque estos receptores de mensajes no muestran información en la interfaz del usuario, sí que pueden crear una notificación en la barra de estado (la barra que aparece arriba en Android) para alertar al usuario cuando se produce este tipo de mensajes. Un receptor de mensajes se implementa a partir de la clase BroadcastReceiver y cada mensaje emitido es un objeto del tipo Intent (Intención). Más adelante veremos cómo se usa.  Componentes de la pantalla de inicio (Widgets): estos componentes visuales se usan principalmente en la Pantalla de inicio (HomeScreen) de Android para mostrar información que se actualiza periódicamente como, por ejemplo, un reloj, la previsión del tiempo, etcétera. Al tratarse de programación avanzada no los estudiaremos en este curso de iniciación a Android.  Otros componentes de Android son las Carpetas animadas (Live Folders) y los Fondos de pantalla animados (Live Wallpapers) en la Pantalla de Inicio. Las carpetas animadas permiten a Android mostrar información en la pantalla inicial sin necesidad de lanzar la aplicación correspondiente. Igualmente, al tratarse de programación avanzada, no los estudiaremos en este curso de iniciación a Android.

Un aspecto único del diseño del sistema Android es que cualquier aplicación puede iniciar un componente de otra aplicación. Por ejemplo, si es necesario para la aplicación abierta capturar una imagen con la cámara de fotos, seguramente ya exista otra aplicación que hace eso y que la aplicación inicial puede reutilizar en lugar de desarrollar el código necesario para capturar la foto. Únicamente hay que iniciar la actividad de la aplicación de la cámara de fotos y capturar la imagen. La sensación del usuario es como si la cámara formara parte de la aplicación inicial. Cuando el sistema arranca un componente, éste inicia un proceso (si no está ya en ejecución) para que la aplicación cree las instancias de las clases necesarias del componente. 39

Por ejemplo, si una aplicación inicia la actividad de la aplicación de la cámara que hace fotos, la actividad se ejecuta en el proceso que pertenece a la aplicación de la cámara, no en el proceso de la aplicación original que ha hecho la llamada a la otra aplicación. Por lo tanto, a diferencia de otros sistemas operativos, las aplicaciones de Android no tienen un punto de entrada único (no hay función main()). Debido a que el sistema ejecuta cada aplicación en un proceso independiente con permisos restringidos, ésta no puede activar directamente un componente de otra aplicación, sino que es el sistema operativo Android el encargado de hacerlo. Por lo tanto, para activar un componente de otra aplicación es necesario enviar un mensaje al sistema que especifica su intención (clase Intent) de iniciar un componente en particular. Por lo tanto, el sistema operativo es el encargado de activar el componente solicitado.

1.3

CÓMO CREAR UN PROYECTO ANDROID

1.3.1 Un vistazo general al IDE de Eclipse Antes de crear el primer proyecto de Android, vamos a echar un primer vistazo al entorno de desarrollo de Eclipse para conocer sus características básicas, la forma en que organiza el proyecto y las herramientas adicionales que ofrece. La primera vez que se ejecuta Eclipse se puede ver una pantalla muy similar a la que se muestra a continuación.

40

Introducción al entorno Android

1.3.1.1

Editores

La ventana principal (la más grande) se llama “Editor”. El Editor es el espacio donde se escribe el código fuente de los programas que estamos desarrollando. Es posible tener varios ficheros de código fuente abiertos a la vez, apilados uno encima de otro. En la parte superior de la ventana del Editor se muestran las pestañas que permiten acceder a cada uno de los ficheros abiertos (o bien cerrarlos directamente).

Editor

1.3.1.2

Vistas

Además del Editor, existe un segundo tipo de ventanas “secundarias”, que se llaman Vistas. Las Vistas son ventanas auxiliares para mostrar información, introducir datos, etcétera. Las Vistas se usan con múltiples propósitos, desde navegar por un árbol de directorios, hasta mostrar el contenido de una consulta SQL.

41

Vistas

En función de las librerías de desarrollo (Android, GWT, Java, Delphi...) se definen Editores propios y todas las Vistas necesarias. En la ventana anterior están abiertas dos Vistas: 

La Vista vertical de la izquierda muestra el árbol de directorios de los proyectos con los ficheros del mismo.



La Vista horizontal inferior muestra una pequeña “agenda” de tareas pendientes que pueden ser introducidas por el usuario, de forma directa, o por Eclipse, en función de determinados eventos (compilación del proyecto, depuración de código, etcétera).

Si deseamos cambiar las Vistas, se puede usar la opción “Show View” en el menú de la pestaña “Window”.

42

Introducción al entorno Android

1.3.1.3

Barras de Herramientas principal y secundarias

La barra de herramientas principal contiene los accesos directos a las operaciones más comunes, como abrir y guardar archivos. Además, también es posible ejecutar herramientas externas y tareas relacionadas con el Editor activo, como ejecutar un programa, depurar el código fuente, etcétera.

Además de la barra de herramientas principal (imagen anterior), cada Vista puede tener su propia barra de herramientas secundaria.

1.3.1.4

Perspectivas

Una Perspectiva es un conjunto de ventanas (Editores y Vistas) agrupadas que simplifican el desarrollo de un proyecto. Al seleccionar una Perspectiva se carga una configuración guardada de las Vistas y Editores de nuestro entorno de desarrollo Eclipse. Por ejemplo, existe una Perspectiva "Java Browsing" que facilita el desarrollo de aplicaciones Java y que incluye, además del Editor, Vistas para navegar por las clases, los paquetes, etcétera. Se puede cambiar la perspectiva activa utilizando la opción “Open Perspective” del menú de Windows. Desde este mismo menú también es posible definir Perspectivas personalizadas.

43

También existe un botón en la barra de herramientas principal para cambiar de Perspectiva:

Si el alumno tiene dudas sobre el uso avanzado de Eclipse, en Internet existen muchos tutoriales que indican cómo utilizarlo. Además, es posible usar el menú "Help" o la tecla [F1] para solicitar ayuda. Desgraciadamente, a día de hoy, esta ayuda sólo se encuentra en inglés.

Importante: para importar en Eclipse el código fuente de los ejemplos del curso hay que usar la opción del menú principal: File -> Import.

44

Introducción al entorno Android

Después, hay que marcar Existing Proyects into Workspace en la ventana emergente y pulsar en el botón “Next”:

Finalmente, seleccionamos el directorio de trabajo donde debemos haber copiado previamente

los

ficheros

con

el

código

fuente

de

los

ejemplos:

“C:\cursos_Mentor\Android\proyectos” y hacemos clic en “Finish”:

45

Nota: en esta Unidad 1 puedes encontrar el vídeo “Cómo cargar los ejemplos en Eclipse”, que muestra cómo se importan los ficheros con el código fuente de los proyectos que son los ejemplos del curso.

Importante: en el apartado “Problemas al cargar proyectos de Android” de Preguntas y Respuestas (FAQ) de la Unidad 1 puedes encontrar soluciones a los problemas que ocurren al importar el código fuente de los ejemplos del curso.

1.3.2 Cómo crear un proyecto Android A continuación, vamos a describir cómo crear un proyecto usando Eclipse y las librerías de Android que hemos instalado con anterioridad. Se trata del primer proyecto que el alumno va a crear, por lo que es muy importante prestar atención a los pasos seguidos, ya que los proyectos siguientes se generan de manera similar.

Así pues, arrancamos Eclipse.

46

Introducción al entorno Android

1.3.2.1

Creación de un nuevo proyecto

En el menú de Eclipse hacemos clic en File->New->Project:

También podemos hacer clic en el botón del menú de herramientas de Eclipse haciendo clic en la opción “Open a wizard to help create a new Android project”:

A continuación, aparece una nueva ventana en la que escribimos el nombre de proyecto "unidad1.eje1.bienvenido", "es.mentor.unidad1.eje1.bienvenido" para el paquete de java (Package) y “Bienvenido” para Activity. El resto de opciones las dejamos como aparecen en la siguiente captura de pantalla:

47

   Pulsamos el botón “Finish” para crear los ficheros del proyecto. A continuación, describimos los apartados que genera un proyecto Android:



Project Name: como su nombre indica es el nombre del proyecto Eclipse; corresponde con el nombre del directorio que contiene los ficheros del proyecto.



Build Target: indica la versión del Android SDK que vamos a usar para compilar la aplicación. Por ejemplo, si seleccionas Android 2.3, la aplicación se compilará para funcionar en esta versión de Android y las siguientes. La versión seleccionada aquí no tiene que coincidir con la versión del Emulador de Android (AVD), ya que las aplicaciones de Android están diseñadas de manera que se

48

Introducción al entorno Android

ejecutan en la plataforma en la que se desarrollaron y en todas las versiones superiores de Android. Por ejemplo, una aplicación que de desarrolló para la versión 2.1 se ejecutará bien en la versión 2.3.3. Al contrario no funciona. 

Application Name: es el nombre de la aplicación que aparece en el icono del Escritorio de Android. Es el texto que ve el usuario del teléfono.



Package Name: es el nombre del paquete Java en el que se almacena todo el código fuente de la aplicación.



Create Activity: define el nombre de la Actividad.

Importante: El nombre del paquete debe ser único en relación con todos los paquetes instalados en Android. Por esta razón, es importante utilizar el estándar de dominio para nombrar los paquetes de las aplicaciones. En el ejemplo anterior se utiliza el nombre de paquete "es.mentor". A la hora de desarrollar tus propias aplicaciones y distribuirlas en el Android Market (Mercado de aplicaciones Android) debes utilizar nombres propios de paquetes. En ningún caso debes utilizar el nombre “es.mentor” para distribuir aplicaciones en el Android Market, pues sólo es válido para los ejemplos del curso.

1.3.2.2

Nombre de la actividad

Importante: El nombre de la actividad no puede incluir tildes, la letra “ñ”, ni caracteres raros.

1.3.2.3

Descripción de los ficheros por defecto del proyecto

Para ver los ficheros del proyecto Android creados por Eclipse, en la barra lateral Package Explorer, desplegamos las entradas haciendo clic en los ficheros marcados con flechas rojas de los diferentes paquetes:

49

A continuación, vamos a explicar la estructura y contenido de los ficheros del proyecto. Carpeta/src/ Contiene todo el código fuente de la aplicación, código de la interfaz gráfica, clases auxiliares, etcétera. Inicialmente, Eclipse crea el código básico de la Actividad (Activity) principal de la aplicación, debajo del paquete Java definido. Carpeta /res/ Contiene todos los ficheros de recursos necesarios para el proyecto: imágenes, vídeos, cadenas de texto (para internacionalización de la aplicación), etcétera. Los diferentes tipos de recursos se deben distribuir entre las siguientes subcarpetas: 

/res/drawable-X/: contiene las imágenes de la aplicación. Se divide en /drawableldpi, /drawable-mdpi y /drawable-hdpi para utilizar diferentes recursos dependiendo de la resolución del dispositivo.



/res/layout/: contiene los ficheros de definición de las diferentes pantallas de la interfaz gráfica. Se puede usar la carpeta /layout y /layout-land para definir los diferentes diseños en función de la orientación del dispositivo.



/res/anim/. alberga la definición de las animaciones utilizadas por la aplicación.



/res/menu/: contiene la definición de los menús de la aplicación.



/res/values/: contiene otros recursos de la aplicación como, por ejemplo, cadenas de texto (strings.xml), estilos (styles.xml), colores (colors.xml), etcétera.

 50

/res/xml/: contiene los ficheros XML utilizados por la aplicación.

Introducción al entorno Android 

/res/raw/: contiene los recursos adicionales, normalmente en diferente formato a XML, que no se incluyan en el resto de carpetas de recursos.

Carpeta /gen/ Reúne una serie de elementos de código generados automáticamente al compilar el proyecto. Cada vez que compilamos el proyecto, Android genera una serie de ficheros fuente Java dirigidos al control de recursos de la aplicación. El archivo más importante es el que se puede observar en la imagen anterior, el fichero R.java que define la clase Java denominada R. Esta clase R contiene un conjunto de constantes con los ID de todos los recursos de la aplicación incluidos en la carpeta /res/, de forma que el programador pueda acceder fácilmente a estos recursos desde el código fuente a través de esta clase. Así, por ejemplo, la constante R.drawable.icon define el ID de la imagen “icon.png” contenida en la carpeta /res/drawable/. Veamos como ejemplo la clase R creada por defecto para el proyecto nuevo:

/* AUTO-GENERATED FILE. DO NOT MODIFY. * * This class was automatically generated by the * aapt tool from the resource data it found. It * should not be modified by hand. */ package es.mentor.unidad1.eje1.bienvenido; public final class R { public static final class attr { } public static final class drawable { public static final int icon=0x7f020000; } public static final class layout { public static final int main=0x7f030000; } public static final class string { public static final int app_name=0x7f040001; public static final int hello=0x7f040000; } }

Importante: Esta clase la crea automáticamente Android por lo que no debemos modificarla.

51

Carpeta /assets/ Alberga el resto de ficheros auxiliares necesarios para que aplicación funcione, como los ficheros de configuración, de datos, etcétera. La diferencia entre los recursos incluidos en la carpeta /res/raw/ y los incluidos en la carpeta /assets/ es que para los primeros se generará un ID en la clase R y se deberá acceder a ellos usando un método de esta clase. Sin embargo, para los segundos no se generarán un ID y se puede acceder a ellos por su ruta como a cualquier otro fichero del sistema. Aplicaremos unos u otros según las necesidades de nuestra aplicación. Carpeta /bin/ Es el directorio donde se guarda la aplicación una vez se ha compilado. Carpeta /libs/ Es el directorio donde se almacenan las librerías de tipo JAR que amplían las funcionalidades de la aplicación. Fichero AndroidManifest.xml: Contiene la definición en formato XML de las características principales de la aplicación, como, por ejemplo, su identificación (nombre, versión, icono, etcétera), sus componentes (Actividades, Mensajes, Servicios, etcétera) o los permisos necesarios para su ejecución. Veremos más adelante otros detalles de este fichero.

Importante: Haciendo doble clic sobre estos ficheros podemos abrirlos en el Editor de Eclipse. Es importante que el alumno se familiarice con este entorno de desarrollo y pruebe las distintas opciones del mismo.

Al abrir los distintos ficheros veremos la siguiente ventana:

52

Introducción al entorno Android

1.3.2.4

Ejecución del proyecto Android

Una vez hemos creado el proyecto, vamos a explicar cómo ejecutamos esta aplicación de prueba con Eclipse y el emulador de Android (AVD: Android Virtual Device). Para ello, hacemos clic en el botón "Ejecutar" de la barra de herramientas principal

o en la opción "Run" de menú “Run”. También disponemos del atajo del teclado [Ctrl+F11]

53

Si no aparece ningún problema de compilación, entonces aparecerá la siguiente ventana:

Eclipse inicia el emulador de Android AVD en el ordenador que estés utilizando, para que puedas probar el proyecto que has desarrollado. Ten en cuenta que el dispositivo virtual tarda un rato en cargar cada vez que lo inicias. Hay que tener un poco de paciencia hasta que parezca la ventana de inicio.

54

Introducción al entorno Android

En la consola de Eclipse puedes ir viendo el progreso de todo el proceso. Eclipse instala automáticamente la nueva aplicación en el AVD y la ejecuta:

Cuando accedemos por primera vez al emulador, aparece la pantalla de bienvenida con el terminal bloqueado:

Para desbloquear la pantalla hay que arrastrar el icono "candado" con el ratón hacia la derecha. Una vez desbloqueado el AVD, podemos ver el aspecto de la aplicación instalada:

55

Importante: En general, cada vez que modifiquemos el código fuente y deseemos probar de nuevo nuestro proyecto no es necesario parar el emulador de aplicaciones y arrancarlo de nuevo; simplemente hacemos clic de nuevo en el botón “Run” y Eclipse compilará, reinstalará y ejecutará la aplicación modificada. Una vez hayamos acabado de probar nuestro proyecto, es necesario parar el emulador de Android.

Atención: En el Emulador de Android es posible probar varios proyectos a la vez.

Nota: En esta Unidad 1 puedes encontrar el vídeo “Cómo ejecutar un proyecto Android”, que muestra cómo usar Eclipse para compilar y ejecutar los proyectos que son los ejemplos del curso.

1.3.2.5

Cómo usar el emulador de Android (AVD)

Como puedes observar, el Emulador de Android simula un teléfono con botones (lado derecho de la ventana). Si ya sabes utilizar este tipo de teléfonos no tendrás ningún problema en manejar el emulador como si fuera un teléfono más. Si no conoces Android, lee las siguientes instrucciones para ver cómo se maneja. Cambiaremos el idioma del sistema operativo. 56

Introducción al entorno Android

El botón “Volver a atrás”, permite cerrar la aplicación y volver al “Escritorio” de Android:

En la pantalla que aparece a continuación, debemos desbloquear el dispositivo virtual. Para ello, arrastramos con el ratón la barra que tiene un candado dibujado hacia la derecha:

Después, aparece la pantalla denominada “Pantalla Inicial” (en inglés se denomina Home Screen), podemos acceder a todas las actividades instaladas haciendo clic en el icono marcado con una flecha roja en la imagen siguiente:

57

Si lo hacemos, veremos las aplicaciones instaladas. A esta pantalla se la denomina Pantalla de lanzamiento (en inglés se denomina Launcher Screen):

58

Introducción al entorno Android

Para movernos en esta pantalla, podemos usar el ratón como si fuera el dedo de tu mano. Es decir, para ver los iconos que están abajo hay que hacer clic en la pantalla y, sin soltar el botón del ratón, arrastrar la ventana hacia arriba:

Arrastrar hacia abajo con el ratón

Haciendo clic con el ratón sobre el icono de una de las aplicaciones, el emulador la ejecutará. A continuación, vamos a modificar el idioma del sistema operativo. Para ello, haciendo clic en el icono “Settings” aparece la siguiente pantalla:

Arrastrar hacia con el ratón

abajo

59

Desplazando con el ratón hacia arriba esta ventana hacemos clic en “Language & keyboard”:

En la siguiente pantalla hacemos clic en “Select language”:

60

Introducción al entorno Android

Para acabar, desplazamos de nuevo la pantalla hacia arriba hasta que veamos el idioma en el que deseamos configurar Android:

Arrastrar hacia con el ratón

abajo

Hacemos clic sobre el idioma correspondiente y el sistema operativo queda configurado:

61

Después, debemos desmarcar la opción “Japanese IME” de esta pantalla:

Si usamos el botón “Volver atrás”, veremos que el idioma del sistema operativo ha cambiado en la Pantalla Inicial (Home Screen):

62

Introducción al entorno Android

En el apartado “Uso del emulador de Android” de la Unidad 2 puedes encontrar una descripción más ampliada y detallada del AVD.

1.4

CÓMO CREAR LA PRIMERA APLICACIÓN CON ANDROID

A continuación, vamos a explicar cómo crear un proyecto sencillo usando Eclipse y las librerías Android. Vamos a partir del proyecto de ejemplo que hemos creado en el punto anterior. El primer proyecto Android consiste en una pantalla muy sencilla que muestra un mensaje de bienvenida. En la barra lateral Package Explorer de Eclipse, desplegamos las entradas haciendo clic en las flechas de los diferentes paquetes.

Si abrimos el fichero BienvenidoActivity.java, veremos el código fuente de la aplicación Android:

63

package es.mentor.unidad1.eje1.bienvenido; import android.app.Activity; import android.os.Bundle; import android.widget.TextView;

public class BienvenidoActivity extends Activity { /** Método que se llama cuando se crea una actividad. */ public void onCreate(Bundle savedInstanceState) { // Llamamos al método de la clase superior (Activity) super.onCreate(savedInstanceState); // Establecemos los contenidos de la Intefaz de usuario // de forma “programada”. TextView tv = new TextView(this); tv.setText("¡Bienvenido al curso de Android de Mentor!"); setContentView(tv); // Descomentar la siguiente sentencia para usar los layout en // el diseño de la Interfaz Usuario. Si lo haces, debes // comentar las 3 sentencias anteriores. // setContentView(R.layout.main); } }

Fíjate en que la clase principal BienvenidoActivity de la aplicación se basa en la clase Activity de Android. Una actividad (Activity) es el componente de la aplicación que realiza acciones. Una aplicación puede tener muchas actividades, si bien el usuario sólo interactúa con ellas de una en una. Android llama al método onCreate() cuando una actividad se inicia. En este método se lleva a cabo toda la inicialización de variables y configuración de la interfaz de usuario. Una actividad no está obligada a tener una interfaz de usuario, aunque generalmente la suele tener.

En la Unidad 2 veremos en detalle todos los métodos disponibles en esta clase básica de Android. 64

Introducción al entorno Android

La interfaz de usuario de Android se compone de vistas (Views). Una vista es un objeto que define el diseño de la interfaz de usuario. como un botón, una imagen, una etiqueta de texto, etcétera. Cada uno de estos objetos se hereda de la clase principal View. En este ejemplo hemos utilizado la subclase TextView, que crea una etiqueta de texto. En el ejemplo se crea una etiqueta TextView en el constructor de la Actividad. Para crear esta etiqueta es necesario pasar como parámetro una instancia del Contexto (Context) de la aplicación Android. Un Contexto es un identificador del sistema que sirve para tener acceso a recursos, a preferencias, a bases de datos, etcétera, de la aplicación. La clase Actividad se hereda de la clase Contexto; por lo tanto, se puede pasar esta Actividad como el Contexto de la aplicación escribiendo this. Con el método setText() establecemos el texto contenido en la etiqueta.

Para acabar, usamos el método setContentView() para indicar a la Actividad el contenido de la interfaz de usuario.

Si ejecutas la aplicación en Eclipse deberás ver la siguiente ventana en el emulador:

65

Nota: Al ejecutar varias veces una aplicación desde Eclipse puede ocurrir que aparezcan los siguientes mensajes de error en la consola:

Estos mensajes de error: [2011‐11‐20 09:18:15 ‐ unidad1.eje1.bienvenido] Application already deployed.  No need to reinstall.  [2011‐11‐20  09:18:15  ‐  unidad1.eje1.bienvenido]  Starting  activity  es.mentor.unidad1.eje1.bienvenido.BienvenidoActivity on device emulator‐5554  [2011‐11‐20 09:18:16 ‐ unidad1.eje1.bienvenido] ActivityManager: Starting:  Intent { act=android.intent.action.MAIN  cat=[android.intent.category.LAUNCHER]  cmp=es.mentor.unidad1.eje1.bienvenido/.BienvenidoActivity}  [2011‐11‐20 09:18:16 ‐ unidad1.eje1.bienvenido] ActivityManager: Warning:  Activity not started, its current task has been brought to the front  Indican únicamente que no se ha modificado el código fuente y que la aplicación se muestra de nuevo en el primer plano de la pantalla del dispositivo virtual.

1.4.1 Cambio en la Interfaz de usuario con Layout Los Layout son elementos no visibles que establecen cómo se distribuyen en la interfaz del usuario los componentes (widgets) que incluyamos en su interior. Podemos pensar en estos elementos como paneles donde vamos incorporando, de forma diseñada, los componentes con los que interacciona el usuario. Nota: La clase Layout se hereda, como el resto de componente, de la clase Vista. A lo largo del curso nos referimos a los componentes de Android como Vistas (Views) o como Widgets, tanto si son visibles (botones, texto, menús….) como si son elementos de diseño (layout).

En el ejemplo anterior hemos utilizado un diseño de interfaz de usuario "programado", es decir, se construye esta interfaz con sentencias Java en el código fuente. Si ya has desarrollado interfaces de esta manera, sabrás que pequeños cambios en su diseño pueden dar lugar a grandes modificaciones en el código fuente.

66

Introducción al entorno Android

Al ser Android un lenguaje nuevo, permite desarrollar interfaces usando archivos de diseño (Layout) XML. La forma más fácil de explicar este concepto es mostrar un ejemplo. El fichero res/layout/main.xml define el diseño de la interfaz del usuario:



La estructura general de un archivo de diseño de interfaz XML de Android es simple. Se trata de un árbol de elementos XML, donde cada nodo es el nombre de una clase Vista (en este ejemplo, usamos las clases LinearLayout y TextView). Puedes utilizar el nombre de cualquier clase de tipo Vista (View) de Android o, incluso, una clase Vista personalizada por el programador. El Layout LinearLayout apila secuencialmente todos sus elementos hijos de forma horizontal o vertical. En el apartado siguiente veremos diferentes tipos de paneles de diseño y sus características. Esta estructura XML hace que sea más fácil y rápido crear las interfaces de usuario. Este modelo se basa en el modelo de desarrollo web, donde se separa la presentación (interfaz de usuario) de la lógica de la aplicación (encargada de leer y escribir la información). En el ejemplo de XML anterior sólo hay un elemento Vista: TextView, que tiene tres atributos y un elemento de diseño Layout: LinearLayout, que tiene cuatro atributos. A continuación, mostramos una descripción de los atributos:

67

Atributo

Descripción

xmlns:android

Esta declaración indica que vamos a usar el espacio de nombres (la terminología) de Android para referirnos a los atributos que se definen a continuación.

android:id

Asigna un identificador único para el elemento correspondiente. Este identificador sirve para poder acceder al componente desde el código fuente o desde las declaraciones de otros elementos en este archivo XML.

Define el largo que debe ocupar la Vista. En este caso, indicamos que android:layout_width el TextView debe ocupar toda la pantalla con "fill_parent”.

android:layout_height

android:text

Similar al atributo anterior, en este caso, se refiere al ancho de la Vista.

Establece el texto que la Vista TextView debe mostrar. En este ejemplo se utiliza una cadena que se establece en el archivo res/values/strings.xml.

El título de la aplicación “Unidad1 - Ejemplo 1: Bienvenido” y la frase "¡Bienvenido al curso de Android de Mentor!", que aparecen en el área del usuario, se definen en el fichero res/values/strings.xml. El SDK de Android permite definir los ficheros de tipo XML de dos formas: a través de un editor visual o directamente en el archivo XML. Se puede cambiar entre las dos formas haciendo clic en la pestaña de la parte inferior de la ventana. Por ejemplo, en el Package Explorer, seleccionamos res/layout/main.xml y hacemos clic en “Graphical Layout”:

68

Introducción al entorno Android

En esta ventana podemos diseñar visualmente la pantalla de la aplicación Android arrastrando con el ratón los componentes que aparecen en el apartador “Palette”. Si en el Package Explorer seleccionamos res/layout/strings.xml y hacemos clic en “Resources”:

Usando en esta ventana el botón “Add” podemos añadir visualmente los diferentes tipos de recursos de Android. Para crear la primera aplicación hemos usado componentes (Widgets o Vistas) usuales de Android. En el siguiente apartado de teoría explicaremos en detalle el tipo de componentes disponibles por defecto y cómo usarlos para diseñar las pantallas que servirán de interfaz gráfica al usuario. Fichero AndroidManifest.xml: contiene la definición en formato XML de las características principales de la aplicación, como su identificación (nombre, versión, icono, etcétera), sus componentes (Actividades, Mensajes, Servicios, etcétera) o los permisos necesarios para su ejecución. Más adelante veremos otros detalles de este fichero. En este fichero hay que declarar la Actividad para que Android tenga acceso a la misma. Si abres el archive manifest, verás que existe el siguiente elemento :

69

  0; } // Método que borra una nota public boolean borraNota(long id) { // Usamos la función delete del SQLiteDatabase return basedatos.delete(TABLA_BD, CAMPO_ID + "=" + id, null) > 0; } // Devuelve un Cursor con la consulta a todos los registros de la BD public Cursor obtenerNotas() { return basedatos.query(TABLA_BD, new String[] { CAMPO_ID, CAMPO_CATEGORIA, CAMPO_TITULO, CAMPO_DESCRIPCION }, null, null, null, null, null); } // Devuelve la Nota del id public Cursor getNota(long id) throws SQLException { Cursor mCursor = basedatos.query(true, TABLA_BD, new String[] { CAMPO_ID, CAMPO_CATEGORIA, CAMPO_TITULO, CAMPO_DESCRIPCION }, CAMPO_ID + "=" + id, null, null, null, null, null); // Nos movemos al primer registro de la consulta if (mCursor != null) { mCursor.moveToFirst();

302

Introducción al entorno Android

} return mCursor; } // Método que crea un objeto ContentValues con los parámetros indicados private ContentValues crearContentValues(String categoria, String titulo, String descripcion) { ContentValues values = new ContentValues(); values.put(CAMPO_CATEGORIA, categoria); values.put(CAMPO_TITULO, titulo); values.put(CAMPO_DESCRIPCION, descripcion);

return values; } }

6.3.4

Recursos de diseño XML A continuación, indicamos los ficheros XML de Layout que componen el diseño de la

interfaz del usuario: 

res/menu/menu_listado.xml: define el diseño del menú principal de la aplicación.



res/layout/main.xml: define el diseño de la pantalla de la actividad principal NotasActivity.



res/layout/editar_nota.xml: define el diseño de la actividad secundaria GestionarNota, que sirve para editar y dar de alta notas.



res/layout/fila_notas.xml: define el diseño de los elementos del ListView de la actividad principal, es decir, el estilo de cada nota en el listado.

El alumno o alumna puede abrir estos ficheros en su ordenador y ver cómo están implementados los distintos diseños. Además, se definen los dos ficheros strings.xml y categorias.xml en la carpeta res/values con los literales que usa la aplicación.

303

6.3.5

Actividades Como hemos comentado, la aplicación está formada por dos actividades: la actividad

principal (NotasActivity) muestra un listado con todas las notas y la segunda (GestionarNota) sirve para editarlas o dar de alta una nueva. Veamos el contenido de la actividad principal:

public class NotasActivity extends ListActivity { private NotasBDAdapter bdHelper; private static final int ACTIVIDAD_NUEVA = 0; private static final int ACTIVIDAD_EDITAR = 1; private static final int MENU_ID = Menu.FIRST + 1; private Cursor cursor;

@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // Hacemos más ancha la línea de división entre elementos en el listado this.getListView().setDividerHeight(3);

// Creamos el adaptador que conecta con la BD bdHelper = new NotasBDAdapter(this); // Cargamos todos los datos bdHelper.abrir(); cargaDatos(); // Indicamos el menú contextual asociado al listado registerForContextMenu(getListView()); } // Creamos el menú principal @Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.menulistado, menu);

304

Introducción al entorno Android

return true; } // El usuario hace clic en una opción del menú principal @Override public boolean onMenuItemSelected(int id, MenuItem item) { // Buscamos la opción del menú principal seleccionada switch (item.getItemId()) { case R.id.insertar: // Creamos una actividad indicando el tipo de petición // "ACTIVIDAD_NUEVA" y esperamos el resultado de la misma Intent i = new Intent(this, DetallesNota.class); startActivityForResult(i, ACTIVIDAD_NUEVA); // Indicamos que hemos manejado la opción del menú return true; } return super.onMenuItemSelected(id, item); } // El usuario hace clic en una opción del menú contextual del listado @Override public boolean onContextItemSelected(MenuItem item) { // Buscamos la opción del menú contextual seleccionada switch (item.getItemId()) { case MENU_ID: // Obtenemos el id del elemento seleccionado AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo(); // Borramos ese registro bdHelper.borraNota(info.id); // Recargamos los datos cargaDatos(); // Indicamos que hemos manejado la opción del menú return true; } return super.onContextItemSelected(item);

305

} // Cuando hacemos clic en un elemento del listado, se edita la Nota @Override protected void onListItemClick(ListView l, View v, int position, long id) { super.onListItemClick(l, v, position, id); // Creamos una actividad indicando el tipo de petición // "ACTIVIDAD_EDITAR" y esperamos el resultado de la misma Intent i = new Intent(this, DetallesNota.class); // Pasamos el campo _id como un dato extra i.putExtra(NotasBDAdapter.CAMPO_ID, id); startActivityForResult(i, ACTIVIDAD_EDITAR); } // Método que se llama cuando una subactividad devuelve el resultado @Override protected void onActivityResult(int requestCode, int resultCode, Intent intent) { super.onActivityResult(requestCode, resultCode, intent); // Recargamos los datos si se ha modificado algo. // Es decir, el usuario ha hecho clic en OK if (resultCode == Activity.RESULT_OK) cargaDatos(); } private void cargaDatos() { cursor = bdHelper.obtenerNotas(); // Se indica que a la Actividad principal que controle los recursos // cursor. Es decir, si se termina la Actividad, se elimina esta // Cursor de la memoria startManagingCursor(cursor);

// Indicamos cómo debe pasarse el campo título de (from) a (to) // la Vista de la opción (fila_notas.xml) String[] from = new String[] { NotasBDAdapter.CAMPO_CATEGORIA, NotasBDAdapter.CAMPO_TITULO }; int[] to = new int[] { R.id.fila_categoria, R.id.fila_titulo };

306

Introducción al entorno Android

// Creamos un sencillo adaptador de tipo Matriz // asociado al cursor SimpleCursorAdapter notas = new SimpleCursorAdapter(this, R.layout.fila_notas, cursor, from, to); // Indicamos al listado el adaptador que le corresponde setListAdapter(notas); }

// Creamos el menú contextual @Override public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) { super.onCreateContextMenu(menu, v, menuInfo); menu.add(0, MENU_ID, 0, R.string.menu_borrar); }

// Cuando se acaba la Actividad cerramos la BD // Es muy importante hacer esto para que se escriba toda la información @Override protected void onDestroy() { super.onDestroy(); if (bdHelper != null) { bdHelper.cerrar(); } } }

 

A continuación, vamos a ver el código de la Actividad secundaria o subactividad:

public class GestionarNota extends Activity { private EditText tituloText; private EditText descripcionText;

307

private Spinner categoriaSpinner; // Usamos esta variable para saber si estamos editando (filaId=id) o // se trata de un registro nuevo (filaId=null) private Long filaId; private NotasBDAdapter bdHelper;

@Override protected void onCreate(Bundle bundle) { super.onCreate(bundle); // Creamos un adaptador u abrimos la BD bdHelper = new NotasBDAdapter(this); bdHelper.abrir(); // Dibujamos el UI y buscamos sus Vistas setContentView(R.layout.editar_nota); categoriaSpinner = (Spinner) findViewById(R.id.category); tituloText = (EditText) findViewById(R.id.nota_editar_titulo); descripcionText = (EditText) findViewById(R.id.nota_editar_descripcion); Button aceptaBoton = (Button) findViewById(R.id.nota_editar_boton); // Variable con el ID del registro actual filaId = null; // Obtenemos el campo ID que se debe haber pasado en la invocación // de la actividad si estamos editando el registro Bundle extras = getIntent().getExtras(); // Si extras contiene algo cargamos ese ID if (extras != null) { filaId = extras.getLong(NotasBDAdapter.CAMPO_ID); }

// Cargamos el registro en los componentes de la pantalla cargarRegistro(); // Método del botón OK aceptaBoton.setOnClickListener(new View.OnClickListener() {

308

Introducción al entorno Android

public void onClick(View view) { // Si pulsa este botón guardamos los datos y devolvemos OK a la Actividad String categoria = (String) categoriaSpinner.getSelectedItem(); String titulo = tituloText.getText().toString(); String descripcion = descripcionText.getText().toString();

// Alta de registro if (filaId == null) { bdHelper.crearNota(categoria, titulo, descripcion); } else { // Modificación de registro bdHelper.actualizarNota(filaId, categoria, titulo, descripcion); }

setResult(RESULT_OK); // Acabamos la actividad finish(); }

}); } // end onCreate

private void cargarRegistro() { if (filaId != null) { Cursor nota = bdHelper.getNota(filaId); // Volvemos a dejar que la actividad actual controle el Cursos startManagingCursor(nota); // Obtenemos el campo categoria String categoria = nota.getString( nota.getColumnIndexOrThrow(NotasBDAdapter.CAMPO_CATEGORIA));

for (int i=0; ikeytool -list -alias androiddebugkey "ruta_del_certificado\debug.keystore" -storepass android -keypass android

-keystore

Nota: es necesario usar la versión 6 de Java, pues en la 7 no funciona. Si lo hacemos, veremos la siguiente ventana:

409

A continuación, copiamos en el portapapeles el dato que aparece identificado como “Huella digital de certificado (MD5)”. Después, accedemos a la Web de Google para solicitar una clave de utilización de la API de Google Maps para depurar aplicaciones. En esta Web tendremos que escribir la Huella digital MD5 de nuestro certificado para obtener la clave de uso de la API. En la siguiente imagen se muestra el resultado:

Nota: Observa que hemos borrado intencionalmente parte de la clave, pues, cuando solicites ésta, te darán otra diferente. Ya hemos terminado la preparación del entorno de programación para poder utilizar los servicios de Google Maps dentro de nuestras aplicaciones Android.

8.3.2

Cómo incluir mapas en las aplicaciones Android En el Ejemplo 2 de esta Unidad vamos a desarrollar una aplicación que incluye un

mapa sobre el que podemos hacer unas operaciones sencillas, como cambiar a vista satélite o desplazar el mapa. Para poder ver este proyecto en tu emulador Android es necesario que obtengas la clave de uso de la API de Mapas de Google y la cambies en el fichero de diseño main.xml de la interfaz de usuario. Si no lo haces, arrancará la aplicación del ejemplo pero no se mostrará el mapa, como en la imagen siguiente:

410

Android Avanzado

Hay que tener en cuenta que, a la hora de crear el proyecto Android en Eclipse, tenemos que seleccionar "Google APIs" en el campo "Build Target" en las propiedades del proyecto:

Para incluir un mapa de Google Maps en una aplicación Android, utilizamos el componente MapView. Este componente se puede añadir al diseño de la pantalla como otro componente normal. Sin embargo, para poder usarlo, hay que indicar la clave de uso de Google Maps en el atributo android:apiKey tal y como se muestra a continuación: 411









El atributo anterior indica que la Actividad gestiona los cambios de orientación ocultando el teclado cuando este cambio ocurre. Además, cuando este giro del dispositivo ocurre, Android invoca el método onConfigurationChanged(), en el que se puede volver a dibujar la interfaz de usuario de la Actividad:

/* Se llama a este evento cuando Android cuando cambia la orientación * del dispositivo. ¡CUIDADO! Para que este evento se invoque debemos

428

Android Avanzado

* gestionar de forma MANUAL la funcionalidad de cambio de orientación. * Esto se consigue añadiendo en el archivo AndroidManifest.xml el atributo * android:configChanges="orientation..." * * Si controlamos de forma MANUAL el cambio de orientación, ya no son * necesarios los métodos onSaveInstanceState() y onRestoreInstanceState() * y debemos comentarlos. */ @Override public void onConfigurationChanged(Configuration newConfig) { super.onConfigurationChanged(newConfig); // Si controlamos el cambio, también hay que guardar los contenidos de los componentes visuales String texto = et.getText().toString(); if (newConfig.orientation==Configuration.ORIENTATION_LANDSCAPE) { Toast.makeText(this,

"Cambio

a horizontal", Toast.LENGTH_SHORT).show();

setContentView(R.layout.main); } else { Toast.makeText(this,

"Cambio

a vertical", Toast.LENGTH_SHORT).show();

setContentView(R.layout.main); } //Obtenemos una referencia a las Vistas de la Actividad et = (EditText)findViewById(R.id.editText); //

Escribimos orientación

el

texto

que

tenía

el

EditText

antes

del

cambio

de

et.setText(texto); }

8.4.4 Cambiar la orientación de la pantalla con sentencias Java

429

En ocasiones, es necesario asegurarse de que una aplicación se muestra siempre en una orientación concreta. Por ejemplo, muchos juegos sólo se visualizan bien en modo horizontal. En este caso, mediante sentencias Java, se puede cambiar la orientación de la pantalla con el método setRequestOrientation() de la clase de Activity:

@Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); //Obtenemos una referencia al EditText de la Actividad et = (EditText)findViewById(R.id.editText); }

Además de utilizar el método setRequestOrientation() para cambiar la orientación de la pantalla, también se puede utilizar el atributo android:screenOrientation dentro del elemento en el archivo AndroidManifest.xml. Fíjate en el siguiente ejemplo:





Android Avanzado





Desde Eclipse puedes abrir el proyecto Ejemplo 3 (Orientación) de la Unidad 8. Estudia el código fuente y ejecútalo para mostrar en el emulador una aplicación en la que mostramos cómo manejar la orientación de la pantalla de un dispositivo Android.

Nota: por defecto, el Ejemplo 3 funciona en modo Manual. Si quieres cambiar a

modo

automático, debes modificar el archivo AndroidManifest.xml del proyecto. Atención: el emulador de Android no funciona muy bien a la hora de simular el cambio de orientación del dispositivo. Dependiendo de la versión de Android, algunos cambios de orientación no se pueden hacer o, a veces, un giro emulado del dispositivo destruye la Actividad dos veces antes de cambiar la orientación del terminal. Sin embargo, la teoría y funciones aquí expuestas sí son válidas para un dispositivo real que funcionará correctamente según lo esperado.

8.5

DESPLEGAR APLICACIONES VIRTUALES (AVD) O REALES

ANDROID

EN

DISPOSITIVOS

Para poder desplegar aplicaciones compiladas (tienen la extensión .apk), primero debemos conectar un dispositivo real por USB o arrancar un dispositivo virtual desde Eclipse. Esto es muy útil si queremos ver en funcionamiento los modelos de las actividades obligatorias de este curso, ya que únicamente se entregan compiladas.

Para arrancar manualmente un dispositivo virtual desde Eclipse hay que pulsar el siguiente botón de la barra de herramientas:

Desde la ventana de

dispositivos

virtuales

seleccionamos

el

dispositivo

que

deseamos arrancar y pulsamos el botón "Start": 431

A continuación, arrancará el dispositivo virtual. Si queremos instalar la aplicación en un dispositivo real de Android, no es necesario iniciar ningún dispositivo virtual.

Nota: en el caso de algunos dispositivos reales, dependiendo de la marca de dispositivo Android, puede ser necesario instalar los drivers para que el sistema operativo lo reconozca correctamente.

Además, el dispositivo real debe estar configurado para admitir la instalación de aplicaciones sin firmar por el Android Market. Si accedes en Ajustes->Aplicaciones debes marcar la siguiente opción:

432

Android Avanzado

Una vez disponemos de un dispositivo (real o virtual) de Android ejecutándose o conectado por USB al PC, abrimos una consola de Windows (o del sistema operativo correspondiente) y utilizamos la utilidad adb.exe (Android Debug Bridge) situada en la carpeta platform-tools del SDK de Android. En primer lugar, consultamos todos los identificadores de los dispositivos en ejecución mediante el comando "adb devices". Este comando debe devolver todas las instancias con los dispositivos abiertos:

Los dispositivos que aparezcan con la etiqueta "emulator-xxx" son dispositivos virtuales y los que muestren otra etiqueta son dispositivos reales (teléfonos, tablets, etcétera). Además, los dispositivos que aparezcan con la etiqueta "offline" están conectados, pero no están disponibles al ADB (Android Debug Bridge). Para este ejemplo, hemos seleccionado el dispositivo “emulator-5556“ que corresponde al dispositivo virtual con Android 2.3.3 para instalar una aplicación. Puedes ver el "id" del dispositivo en la ventana del emulador:

433

Tras obtener este identificador del emulador, vamos a instalar la aplicación mediante el comando “adb -s identificador-del-emulador install nombre-fichero-apk“. Fíjate en el siguiente ejemplo:

Una vez instala la aplicación, tenemos que ejecutarla en el dispositivo buscando su icono en la pantalla de aplicaciones:

434

Android Avanzado

Hacemos clic en el icono de la aplicación para ver su resultado:

8.6

CÓMO PUBLICAR APLICACIONES EN EL ANDROID MARKET

El Android Market (en español Mercado de Android) es una tienda de software en línea desarrollada por Google para los dispositivos Android. Es una aplicación que está preinstalada en la mayoría de los dispositivos Android y que permite a los usuarios buscar y descargar aplicaciones publicadas por terceros desarrolladores. Los usuarios también pueden buscar y obtener información sobre aplicaciones a través de una página Web. Las aplicaciones en el Android Market pueden ser gratuitas o de pago. En este apartado vamos a tratar cómo publicar una aplicación gratuita. En este apartado vamos a explicar los pasos para publicar una aplicación en el Android Market.

8.6.1

Alta de cuenta de desarrollador en el Android Market El primer paso obligatorio es darse de alta como desarrollador en el Android Market.

Para ello, necesitamos disponer de una cuenta de Google (GMail). Con el navegador de Internet accederemos a la dirección: 435

http://market.android.com/publish En esta página introducimos el usuario y la contraseña de Google:

La primera vez que accedemos a la página se muestra un asistente para dar de alta una nueva cuenta de desarrollador en el Android Market. Introducimos los datos que se solicitan (nombre del desarrollador, correo electrónico, URL del sitio Web y número de teléfono). Después, pulsamos el enlace "Seguir":

Para poder darnos de alta como desarrolladores del Android Market y publicar aplicaciones, hay que abonar 25,00$. Se trata de una cuota única sin caducidad. Para pagar

436

Android Avanzado

esta cuota podemos usar el servicio Google Checkout o pulsar en "Continuar" para pagar con tarjeta de crédito:

A continuación, aparece el detalle de la factura con el artículo "Android - Developer Registration Free for xxx". En esta página introducimos los datos de nuestra tarjeta de crédito para realizar el pago, así como la dirección postal de facturación donde llegará la correspondiente factura por correo ordinario:

437

Si todo está correcto, el asistente mostrará la siguiente ventana, indicando que "Su pedido se ha enviado al Android Market". Para continuar con el proceso, pulsamos en el enlace "Vuelve al sitio de desarrolladores de Android Market para completar el registro":

Después, leemos la licencia de desarrollador para el Android Market. Si estamos de acuerdo, hacemos clic en el enlace "Acepto las condiciones y deseo asociar la tarjeta de crédito y la cuenta que he registrado anteriormente al Acuerdo de distribución para desarrolladores de Android Market". Pulsamos "Acepto. Continuar":

438

Android Avanzado

El asistente indicará que el registro ha concluido, con el mensaje "Se ha aprobado tu registro en Android Market. Ahora puedes subir y publicar aplicaciones de software en Android Market". A partir de este momento ya podremos usar nuestra cuenta para publicar aplicaciones:

8.6.2

Recomendaciones sobre aplicaciones para Android Market Cuando desarrollemos aplicaciones que vamos a publicar en el Android Market,

debemos prestar especial atención a una serie de características. 8.6.2.1

Recomendaciones sobre aplicaciones para Android Market

Antes de empezar a desarrollar aplicaciones Android que vamos a publicar en el Market, hay que saber que cuando un usuario realiza una búsqueda de una aplicación en el Market usando su dispositivo Android, sólo le aparecerán las aplicaciones que cumplan los filtros (de permisos y de características del dispositivo) y el nivel de API (API Level) indicados en el archivo AndroidManifest.xml. El "API Level" es la versión de Android compatible con la aplicación. Por ejemplo, durante el curso hemos usado la versión 2.3.3 de Android que corresponde con el "API Level" 10. Si publicamos una aplicación desarrollada con esta versión de Android, únicamente será visible y sólo podrá instalarse en dispositivos con una versión igual o superior a la 2.3.3 de Android.

439

Los filtros de permisos permiten a una aplicación solicitar acceso a recursos de Android. Ya hemos estudiado que si, por ejemplo, una aplicación requiere acceder a la cámara de fotos, debemos indicarlo en el archivo AndroidManifest.xml:

Al Indicar estos permisos, esta aplicación no aparecerá en las búsquedas realizadas desde dispositivos Android que no dispongan de cámara de fotos. Es decir, si solicitamos acceder a un recurso (cámara, wifi, bluetooth, etcétera) que el dispositivo no tiene, la aplicación no será visible en el Market. Además, existen otros filtros con las características del dispositivo en el archivo AndroidManifest.xml que hacen que la aplicación aparezca o no en el Market para un dispositivo determinado: •

: establece el tipo de pantalla (resolución mínima) que necesita la aplicación para funcionar.

•

: especifica el uso de características del dispositivo, por ejemplo: o

Para utilizar Bluetooth:

o

Para usar la cámara:

•

: indica las librerías específicas que requiere la aplicación.

Es importante tener en cuenta que cuanto mayores sean los requisitos de hardware (cámara, bluetooth, GPS, brújula, sensor de movimiento, etcétera), la aplicación será visible e instalable en un menor número de dispositivos Android.

8.6.2.2

Buenas prácticas para el desarrollo de aplicaciones Android

A continuación, mostramos algunas recomendaciones a la hora de desarrollar aplicaciones Android útiles, profesionales y fiables: •

Siempre hay que tener en cuenta que estamos desarrollando aplicaciones para dispositivos con pantalla muy pequeña, si son teléfonos, lo que no ocurre en los tablets, y teclado limitado, por lo que las aplicaciones deberían mostrar pocos campos de texto y opciones reducidas.

•

Antes de desarrollar una aplicación Android, es recomendable buscar en el Market si ya existe una aplicación similar. Si queremos que nuestra aplicación sea útil para los usuarios, debe ser interesante, original y sencilla incorporando funciones que no tengan otras.

440

Android Avanzado •

Hay que procurar, en la medida de lo posible, desarrollar aplicaciones que se puedan instalar en el mayor número posible de dispositivos para que tenga más difusión. Por lo tanto, debemos realizar aplicaciones con la versión de Android mínima y los requisitos de hardware básicos.

•

Las aplicaciones deben ser rápidas. Si es necesario realizar algún proceso que pueda tardar unos segundos, es recomendable avisar al usuario o, incluso, usar hilos de ejecución, servicios, etcétera. El usuario de un dispositivo móvil espera siempre rapidez de respuesta.

8.6.3

Generar fichero APK con certificado para Android Market Cuando compilamos un proyecto Android al hacer "Run" en Eclipse, el fichero .apk

(paquete de instalación de la aplicación Android) generado dentro del directorio /bin no es válido para subirlo directamente al Android Market. Si intentamos subir este fichero directamente aparecerá este mensaje:

Market does not accept apks signed with the debug certificate. Create a new certificate that is valid for at least 50 years. Market requires that the certificate used to sign the apk be valid until at least October 22, 2033. Create a new certificate. Market requires the minSdkVersion to be set to a positive 32-bit integer in AndroidManifest.xml. Uno de los requisitos para poder publicar de aplicaciones en Android Market es que el paquete de instalación APK debe estar firmado con un certificado válido de al menos 25 años. A continuación, explicamos cómo hacerlo. En primer lugar, una vez desarrollada y probada la aplicación Android con Eclipse, hacemos clic con el botón derecho del ratón sobre la carpeta del proyecto y seleccionamos la opción "Export" del menú emergente:

441

Abrimos la carpeta "Android" y seleccionamos "Export Android Application"; después, pulsamos el botón "Next":

En la ventana siguiente, en el campo "Project", podemos seleccionar otro proyecto si nos hemos equivocado. Pulsamos de nuevo el botón "Next":

442

Android Avanzado

A continuación, si no disponemos de una clave, seleccionamos la opción "Create new keystore". Introducimos un directorio y nombre para el almacén de claves, por ejemplo C:\cursos_Mentor\Android\claves.android. Introducimos la contraseña para el almacén de claves:

Si ya disponemos de un almacén de claves, seleccionamos "Use existing keystore" y seleccionamos el certificado escribiendo la clave correspondiente. Pulsamos el botón "Next" para seguir. A continuación, escribimos los datos administrativos de la clave que vamos a crear para certificar nuestras aplicaciones: 443

•

Alias: identificador de la clave.

•

Password: contraseña de la clave, debemos guardarla o recordarla pues la necesitaremos cada vez que vayamos a publicar una nueva aplicación o actualizar una ya existente en el Android Market.

•

Confirm: reescribimos la contraseña anterior.

•

Validity (years): validez del certificado, al menos 25 años.

•

First and Last Name: nombre del desarrollador o de la empresa.

•

Organization Unit: departamento.

•

Organization: nombre de la empresa.

•

City or Locality: ciudad.

•

State or Province: provincia.

•

Country Code: código postal de la ciudad.

Tras introducir los datos pulsamos el botón "Next": A continuación, indicamos la carpeta y el nombre del paquete APK compilado que se firma con el certificado anterior y que será el fichero que finalmente subiremos al Android Market. En es caso hemos seleccionado la carpeta C:\cursos_Mentor\Android\androidmarket del curso:

444

Android Avanzado

Si hemos seguido bien los pasos anteriores, ya dispondremos del fichero APK firmado con el certificado que podemos publicar en el Android Market:

8.6.4

Publicar una aplicación Android en el Android Market Vamos a explicar cómo publicar una aplicación firmada con el certificado para que

aparezca en Android Market y los usuarios puedan descargarla e instalarla. Accedemos a la web de Android Market con la cuenta de desarrollador que hemos dado de alta anteriormente escribiendo en la barra de direcciones del navegador:

https://market.android.com/publish/Home Pulsamos en el enlace "Subir aplicación":

445

Aparecerá una pagina donde podemos seleccionar el fichero APK pulsando en "Examinar" para elegir el fichero APK de nuestra aplicación Android firmada con el certificado:

Pulsamos en el botón "Publicar" para subirla al Android Market. Si el paquete APK está correcto y cumple con todos los requisitos (versión de Android, certificado, compilación, etcétera), el asistente muestra el botón "Guardar" y los datos del APK (nombre de la aplicación, nombre de la versión, código de la versión, permisos que necesita, funciones que necesita, tamaño, nombre de la clase Java). Pulsamos el botón "Guardar" para almacenar la aplicación:

446

Android Avanzado

Tras subirlo, pulsamos en el enlace "Activar" para introducir los datos necesarios para publicar la aplicación en el Android Market. Desde esta página podemos activar o desactivar la publicación de las aplicaciones subidas. Por ejemplo, si hemos detectado algún error y no queremos que los usuarios se descarguen una aplicación hasta solucionar el problema, podremos desactivarla:

Si pulsamos el botón "Activar", a continuación, aparece una ventana donde debemos añadir todos los datos requeridos en la pestaña "Información de producto" para acabar de dar de alta la nueva aplicación: •

Capturas de pantalla de la aplicación: al menos debemos subir dos capturas; es recomendable que tengan buena calidad, para que el usuario se haga una idea del aspecto que tiene la aplicación. 447

•

Icono de la aplicación: la aplicación se identifica con un icono que aparece en la parte izquierda de la pantalla del Android Market cuando los usuarios buscan aplicaciones.

•

Imagen promocional, imagen de funciones y vídeo promocional de Youtube: son datos opcionales que sirven para incluir más información de la aplicación.

•

Si no deseamos que la aplicación se anuncie fuera de Android Market, marcamos la Casilla: "No promocionar mi aplicación salvo en Android Market” y en los sitios web o para móviles propiedad de Google. Asimismo, soy consciente de que cualquier cambio relacionado con esta preferencia puede tardar sesenta días en aplicarse".

•

Podemos elegir varios idiomas para escribir la descripción de las funciones y uso de la aplicación. El inglés es obligatorio. En este punto se solicitan los campos: 

Título de la aplicación: nombre que aparece en las búsquedas, no debe ser muy largo (inferior a 30 caracteres).



Descripción: descripción detallada (hasta 4000 caracteres) de la funcionalidad de la aplicación.



Cambios recientes: si se trata de una actualización, podemos indicar aquí las últimas mejoras implementadas.



Si hemos incluido un vídeo promocional, podemos añadir un texto promocional.



Tipo de aplicación: seleccionamos en el desplegable el tipo que más se ajuste a la funcionalidad de la aplicación.



Categoría: seleccionamos en el desplegable la categoría que más se ajuste a la aplicación.

•

Protección contra copias: lo usual es que no esté seleccionada esta opción, ya que, como indica Android Market, esta función quedará obsoleta en breve, siendo sustituida por el servicio de licencias.

•

Clasificación del contenido: marcamos si nuestra aplicación es para todos los públicos o contiene algún tipo de contenido para mayores.

•

Precios: aquí indicamos si la aplicación es gratuita o de pago.

•

Precio predeterminado: si hemos elegido de pago, en este campo introducimos el precio de la aplicación. Pulsando el botón "Autocompletar" hará los ajustes para los diferentes países en los que queramos publicarla.

448

Android Avanzado •

También se indica el número aproximado de modelos de dispositivos Android sobre los que se podrá instalar la aplicación en función de los filtros indicados en el archivo de manifiesto.

•

Información de contacto: o

Sitio web.

o

Correo electrónico.

o

Teléfono.

En la siguiente ventana se muestra parte de los datos que hay que incluir:

Una vez introducidos los datos, pulsamos en el botón "Guardar" de la parte superior derecha. A continuación, se comprueba si los datos son completos y correctos y, si no hay errores, se guardarán los datos asociados al archivo APK. 449

Después, pulsamos en el botón "Publicar" (a la izquierda del botón "Guardar") para publicar definitivamente la aplicación en Android Market:

Tras finalizar la publicación, se mostrará en "Todos los elementos de Android Market" la nueva aplicación con el estado "Publicada". En esta página podemos llevar a cabo un seguimiento del número de instalaciones, posibles errores, comentarios de los usuarios, popularidad, etcétera.

450

Android Avanzado

 La Depuración de programas (en inglés Debug) es el proceso de identificar y corregir errores de programación en tiempo de ejecución.  Un Punto de interrupción (Breakpoint en inglés) es una marca en el código fuente que pausa la ejecución de un programa, para que el programador pueda evaluar los valores asignados a las variables y detectar errores en tiempo de ejecución.  El entorno de desarrollo Eclipse permite llevar a cabo de manera sencilla la Depuración de programas.  Es posible incluir mapas en las aplicaciones de Android haciendo uso de la API Android de Google Maps.  Para poder utilizar la API de Google Maps, es necesario disponer de una clave de uso (API Key) que estará asociada al certificado con el que firmamos digitalmente las aplicaciones.  El Android Market (en español Mercado de Android) es una tienda de software en línea desarrollada por Google para los dispositivos Android.  Para poder publicar aplicaciones en el Android Market, es necesario darse de alta y pagar una cuota.  El paquete de instalación APK de una aplicación del Android Market debe estar firmado con un certificado válido de al menos 25 años.

451