Page 1

UNIVERSIDAD FRANCISCO GAVIDIA DESARROLLO DE APLICACIONES CON ANDROID


Contenido Introducción ................................................................................................................ 1 ¿Qué es Android?........................................................................................................ 2 Características:............................................................................................................ 3 Arquitectura:................................................................................................................ 5 Aplicaciones: ............................................................................................................... 6 Seguridad: ................................................................................................................... 7 Estructura del SDK: ....................................................................................................... 7 Programa cliente-servidor...................................................................................... 10 Cliente: ............................................................................................................... 10 Servidor:.............................................................................................................. 10 Daemon: ............................................................................................................. 10 Herramientas de Desarrollo: ...................................................................................... 11 Android SDK............................................................................................................ 11 Native Development Kit. Desarrollo Nativo ........................................................... 12 Android Open Accessory Development Kit .......................................................... 12 App Inventor para Android ................................................................................... 13 HyperNext Android Creator ................................................................................... 13 El proyecto Simple.................................................................................................. 13 Android Studio:....................................................................................................... 14 RADDroid: ............................................................................................................... 14 DroidDraw para construir interfaces de usuario:................................................... 15 ADT Bundle: ............................................................................................................ 16 Eclipse:.................................................................................................................... 16 Creación de dispositivos Virtuales:............................................................................ 16 Creando nuestro dispositivo virtual........................................................................ 17 Ejecutando el dispositivo ....................................................................................... 19 Emulador de Android............................................................................................. 20 Estructura de un Proyecto Android: .......................................................................... 22 Pasos para la creación de un proyecto ................................................................... 24 Crear un proyecto con Eclipse: ............................................................................. 24 Controles para Android:............................................................................................ 26


Input Controls ............................................................................................................ 26 Buttons ........................................................................................................................ 27 Text Fields................................................................................................................... 28 Password .................................................................................................................... 29 Checkboxes................................................................................................................. 30 Radio Buttons .............................................................................................................. 31 Toggle Buttons ............................................................................................................ 32 Rating Bar ................................................................................................................... 32 Spinners ...................................................................................................................... 33 Pickers ........................................................................................................................ 34 Analogclock and Digitalclock ........................................................................................ 36 Progress Bar................................................................................................................ 38 Alert Dialog .................................................................................................................. 39 Prompt Dialog .............................................................................................................. 40 Custom Dialog ............................................................................................................. 41 Toasts ......................................................................................................................... 43 View Image.................................................................................................................. 44 ImageButton ................................................................................................................ 45 ImageButton Selector ................................................................................................... 45 LinearLayout ................................................................................................................ 46 RelativeLayout ............................................................................................................. 48 TableLayout................................................................................................................. 50 ListView....................................................................................................................... 51 GridView...................................................................................................................... 53 WebView ..................................................................................................................... 54 Activities ...................................................................................................................... 54


Página | 1

Introducción La telefonía móvil está cambiando la sociedad actual de una forma tan significativa como lo ha hecho Internet. Esta revolución no ha hecho más que empezar, los nuevos terminales ofrecen unas capacidades similares a un ordenador personal, lo que permite que puedan ser utilizados para leer nuestro correo o navegar por Internet. Pero a diferencia de un ordenador, un teléfono móvil siempre está en el bolsillo del usuario. Esto permite un nuevo abanico de aplicaciones mucho más cercanas al usuario. De hecho, muchos autores coinciden en que el nuevo ordenador personal del siglo veintiuno será un terminal móvil. El lanzamiento de Android como nueva plataforma para el desarrollo de aplicaciones móviles ha causado una gran expectación y está teniendo una importante aceptación tanto por los usuarios como por la industria. En la actualidad se está convirtiendo en una seria alternativa frente a otras plataformas como Symbian, iPhone o Windows Phone. Android es considerado como uno de los modelos de negocio más exitosos, pues su desarrollo estratégico contempla los factores que más se tienen en cuenta dentro de las herramientas y metodologías desarrollados por expertos en negocios. Este sistema operativo se ha convertido en un modelo a seguir por desarrolladores de tendencias y negocios de alto impacto

1


Página | 2

¿Qué es Android? Android es un sistema operativo y una plataforma software, basado en Linux para teléfonos móviles. Además, también usan este sistema operativo (aunque no es muy habitual), tablets, netbooks, reproductores de música e incluso PC’s. Android permite programar en un entorno de trabajo (framework) de Java, aplicaciones sobre una máquina virtual Dalvik (una variación de la máquina de Java con compilación en tiempo de ejecución). Además, lo que le diferencia de otros sistemas operativos, es que cualquier persona que sepa programar puede crear nuevas aplicaciones, widgets, o incluso, modificar el propio sistema operativo, dado que Android es de código libre, por lo que sabiendo programar en lenguaje Java, va a ser muy fácil comenzar a programar en esta plataforma.

Figura 1. Sistema de capas de Android En l a im agen se distinguen cl aram ente cada una de l as capas: l a que form a parte del propio Kernel de Linux, donde Android puede acceder a diferentes control adores, l as l ibrerí as creadas para el desarroll o de


Página | 3

aplicaciones Android, l a siguiente capa que organiza l os diferentes administradores de recursos, y por úl tim o, l a capa de l as apl icaciones a l as que tiene acceso.

Características: Características y especificaciones actuales:

Diseño dispositivo

La plataforma es adaptable a pantallas de mayor resolución, VGA, de biblioteca de gráficos 2D, biblioteca de gráficos 3D basada en las especificaciones de la OpenGL ES 2.0 y diseño de teléfonos tradicionales.

Almacenamiento

SQLite, una base de datos liviana, que es usada para propósitos de almacenamiento de datos.

Conectividad

Android soporta las siguientes tecnologías de conectividad: GSM/EDGE, IDEN, CDMA, EVDO, UMTS, Bluetooth, Wi-Fi, LTE, HSDPA, HSPA+, NFC yWiMAX.

Mensajería

SMS y MMS son formas de mensajería, incluyendo mensajería de texto y ahora la Android Cloud to Device Messaging Framework (C2DM) es parte del servicio de Push Messaging de Android.

Navegador web

El navegador web incluido en Android está basado en el motor de renderizado de código abierto W ebKit, emparejado con el motor JavaScript V8 de Google Chrome. El navegador por defecto de Ice Cream Sandwich obtiene una puntuación de 100/100 en el test Acid3.

Soporte de Java

Aunque la mayoría de las aplicaciones están escritas en Java, no hay una máquina virtual Java en la plataforma. El bytecode Java no es ejecutado, sino que primero se compila en un ejecutable Dalvik y corre en la Máquina Virtual Dalvik. Dalvik es una máquina virtual especializada, diseñada específicamente para Android y optimizada para dipositivos móviles que funcionan con batería y que tienen memoria y procesador limitados. El soporte para J2ME puede ser agregado mediante aplicaciones de terceros como el J2ME MIDP


Página | 4

Runner. 45

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

Soporte multimedia

Soporte streaming

Soporte hardware adicional

Entorno desarrollo

Streaming RTP/RTSP (3GPP PSS, ISMA), descarga progresiva de HTML (HTML5 <video> tag). Adobe Flash Streaming (RTMP) es para soportado mediante el Adobe Flash Player. Se planea el soporte de Microsoft Smooth Streaming con el port de Silverlight a Android. Adobe Flash HTTP Dynamic Streaming estará disponible mediante una actualización de Adobe Flash Player.

para

Android soporta cámaras de fotos, de vídeo, pantallas táctiles, GPS, acelerómetros, giroscopios, magnetómetros, sensores de proximidad y de presión, sensores de luz, gamepad, termómetro, aceleración por GPU 2D y 3D.

Incluye un emulador de dispositivos, herramientas para depuración de de memoria y análisis del rendimiento del software. El entorno de desarrollo integrado es Eclipse (actualmente 3.4, 3.5 o 3.6) usando el plugin de Herramientas de Desarrollo de Android.

Google Play

Google Play es un catálogo de aplicaciones gratuitas o de pago en el que pueden ser descargadas e instaladas en dispositivos Android sin la necesidad de un PC.

Multi-táctil

Android tiene soporte nativo para pantallas capacitivas con soporte multi-táctil que inicialmente hicieron su aparición en dispositivos como el HTC Hero. La funcionalidad fue originalmente desactivada a niv el de kernel (posiblemente para evitar infringir patentes de otras compañías).46 Más tarde, Google publicó una actualización para el Nexus One y el Motorola Droid que activa el soporte multi-táctil de forma nativa.47


Página | 5

Bluetooth

El soporte para A2DF y AVRCP fue agregado en la versión 1.5; 48 el envío de archivos (OPP) y la exploración del directorio telefónico fueron agregados en la versión 2.0;49 y el marcado por voz junto con el envío de contactos entre teléfonos lo fueron en la versión 2.2.</ref> Los cambios incluyeron: 50

Videollamada

Android soporta videollamada a través de Google Talk desde su versión HoneyComb.

Multitarea

Multitarea real de aplicaciones está disponible, es decir, las aplicaciones que no estén ejecutándose en primer plano reciben ciclos de reloj.

Características basadas en voz

La búsqueda en Google a través de voz está disponible como "Entrada de Búsqueda" desde la versión inicial del sistema. 51

Tethering

Android soporta tethering, que permite al teléfono ser usado como un punto de acceso alámbrico o inalámbrico (todos los teléfonos desde la versión 2.2, no oficial en teléfonos con versión 1.6 o inferiores mediante aplicaciones disponibles en Google Play (por ejemplo PdaNet). Para permitir a un PC usar la conexión de datos del móvil android se podría requerir la instalación de software adicional. 52

Arquitectura: Los componentes principales del sistema operativo de Android (cada sección se describe en detalle): 

Aplicaciones: las aplicaciones base incluyen un cliente de correo electrónico, programa de SMS, calendario, mapas, navegador, contactos y otros. Todas las aplicaciones están escritas en lenguaje de programación Java.



Marco de trabajo de aplicaciones: los desarrolladores tienen acceso completo a los mismos APIs del framework usados por las aplicaciones base. La arquitectura está diseñada para simplificar la reutilización de componentes; cualquier aplicación puede


Página | 6

publicar sus capacidades y cualquier otra aplicación puede luego hacer uso de esas capacidades (sujeto a reglas de seguridad del framework). Este mismo mecanismo permite que los componentes sean reemplazados por el usuario. 

Bibliotecas: Android incluye un conjunto de bibliotecas de C/C++ usadas por varios componentes del sistema. Estas características se exponen a los desarrolladores a través del marco de trabajo de aplicaciones de Android; algunas son: System C library (implementación biblioteca C estándar), bibliotecas de medios, bibliotecas de gráficos, 3D y SQLite, entre otras.



Runtime de Android: Android incluye un set de bibliotecas base que proporcionan la mayor parte de las funciones disponibles en las bibliotecas base del lenguaje Java. Cada aplicación Android corre su propio proceso, con su propia instancia de la máquina virtual Dalvik. Dalvik ha sido escrito de forma que un dispositivo puede correr múltiples máquinas virtuales de forma eficiente. Dalvik ejecuta archivos en el formato Dalvik Executable (.dex), el cual está optimizado para memoria mínima. La Máquina Virtual está basada en registros y corre clases compiladas por el compilador de Java que han sido transformadas al formato.dex por la herramienta incluida "dx".



Núcleo Linux: Android depende de Linux para los servicios base del sistema como seguridad, gestión de memoria, gestión de procesos, pila de red y m odelo de controladores. El núcleo también actúa como una capa de abstracción entre el hardware y el resto de la pila de software.

Aplicaciones: Las aplicaciones se desarrollan habitualmente en el lenguaje Java con Android Software Development Kit (Android SDK),67 pero están disponibles otras herramientas de desarrollo, incluyendo un Kit de Desarrollo Nativo para aplicaciones o extensiones en C o C++, Google App Inventor, un entorno visual para programadores novatos y varios cruz aplicaciones de la plataforma web


Página | 7

móvil marcos.68 y también es posible usar las bibliotecas Qt gracias al proyecto Necesitas SDK. El desarrollo de aplicaciones para Android no requiere aprender lenguajes complejos de programación. Todo lo que se necesita es un conocimiento aceptable de Java y estar en posesión del kit de desarrollo de software o «SDK» provisto por Google el cual se puede descargar gratuitamente.69 Todas las aplicaciones están comprimidas en formato APK, que se pueden instalar sin dificultad desde cualquier explorador de archivos en la mayoría de dispositivos.

Seguridad: Según un estudio de Symantec de 2013,75 demuestra que en comparación con iOS, Android es un sistema menos vulnerable. El estudio en cuestión habla de 13 vulnerabilidades graves para Android y 387 vulnerabilidades graves para iOS. El estudio también habla de los ataques en ambas plataformas, en este caso Android se queda con 113 ataques nuevos en 2012 a diferencia de iOS que se queda en 1 solo ataque. Aun así Google y Apple se empeñan cada vez más en hacer sus sistemas operativos más seguros incorporando más seguridad tanto en sus sistemas operativos como en sus mercados oficiales.

Estructura del SDK: El SDK contiene un emulador para testear las aplicaciones desarrolladas, emula hw y sw. Requiere de configuraciones AVD (Android Virtual Devices), para testear sobre distintas plataformas Android. (android list avd | android create avd) Para iniciar el emulador: emulator –avd <avd_name>: inicializa el emulador y carga una configuración AVD o vía Eclipse Para finalizarlo, basta con cerrar la ventana. Se puede conectar vía consola textual, usando: telnet localhost 5554 (puerto por usando: telnet localhost 5554 (puerto por defecto) Desde la consola, se pueden simular distintos eventos de hardware (ejemplo: geo fix 41.1 12) o software (sms send) Siglas de Dalvik Debug Monitor Server.


Página | 8

Proporciona información del estado de las instancias Android ya sea dispositivo real o emulador. Middleware entre IDE y device/emulator. Monitoriza, vía el ADB, instancias de máquina virtual. Monitoriza, vía el ADB, instancias de máquina virtual.(un servicio monitorización = 1 puerto = 1 device)


Pรกgina | 9

En IDE Eclipse se puede acceder de forma integrada


P รก g i n a | 10

Siglas de Android Debug Bridge. Gestiona el estado de una instancia del emulador o de un propio dispositivo Android.

Programa cliente-servidor que se compone de: Programa cliente-servidor que se compone de: Cliente: Se ejecuta en la mรกquina desarrollo. Se puede invocar desde un adb shell. (ADT plugin o DDMS). Servidor: Corre en un proceso background en la mรกquina de desarrollo. Gestiona la comunicaciรณn entre cliente & daemon. Daemon: Proceso background en el emulador o dispositivo.


P á g i n a | 11

Herramientas de Desarrollo: Android SDK El SDK (Software Development Kit) de Android, incluye un conjunto de herramientas de desarrollo.5 Comprende un depurador de código, biblioteca, un simulador de teléfono basado en QEMU, documentación, ejemplos de código y tutoriales. Las plataformas de desarrollo soportadas incluyen Linux (cualquier distribución moderna), Max OS X 10.4.9 o posterior, y Windows XP o posterior. La plataforma integral de desarrollo (IDE, Integrated Development Environment) soportada oficialmente es Eclipse junto con el complemento ADT ( Android Development Tools plugin ), aunque también puede utilizarse un editor de texto para escribir ficheros Java y Xml y utilizar comandos en un terminal ( se necesitan los paquetes JDK, Java Development Kit y Apache Ant ) para crear y depurar aplicaciones. Además, pueden controlarse dispositivos Android que estén conectados (e.g. reiniciarlos, instalar aplicaciones en remoto). Las Actualizaciones del SDK están coordinadas con el desarrollo general de Android. El SDK soporta también versiones antiguas de Android, por si los


P á g i n a | 12

programadores necesitan instalar aplicaciones en dispositivos ya obsoletos o más antiguos. Las herramientas de desarrollo son componentes descargables, de modo que una vez instalada la última versión, pueden instalarse versiones anteriores y hacer pruebas de compatibilidad. Una aplicación Android está compuesta por un conjunto de ficheros empaquetados en formato .apk y guardada en el directorio /data/app del sistema operativo Android (este directorio necesita permisos de superusuario, root, por razones de seguridad). Un paquete APK incluye ficheros .dex (ejecutables Dalvik, un código intermedio compilado), recursos, etc.

Native Development Kit. Desarrollo Nativo El NDK permite instalar bibliotecas escritas en C y otros lenguajes, una vez compiladas para ARM o código x86 nativo. Los programas Java corriendo en la máquina virtual Dalvik ( Dalvik VM ) pueden llamar a clases nativas por medio de la función System.loadLibrary, que forma parte de las clases estándar Java en Android. Se pueden compilar e instalar aplicaciones completas utilizando las herramientas de desarrollo habituales. El depurador ADB proporciona un shell root en el Simulador de Android que permite cargar y ejecutar código nativo ARM o x86. Este código puede compilarse con GCC en un ordenador normal. La ejecución de código nativo es difícil porque Android utiliza una biblioteca de C propia (libc, llamada Bionic). Se accede al dispositivo gráfico como un framebuffer disponible en /dev/graphics/fb0. La biblioteca gráfica que utiliza Android para controlar el acceso a este dispositivo se llama Skia Graphics Library (SGL), disponible con licencia de código abierto. Skia tiene implementaciones en win32 y Unix, permitiendo el desarrollo cruzado de aplicaciones, y es el motor de gráficos que soporta al navegador web Google Chrome.

Android Open Accessory Development Kit La plataforma de Android 3.1 (portado también a Android 2.3.4) introduce soporte para Android Open Accesory, que permite interactuar a dipositivos USB externos (accesorios USB Android) interactuar con el dispositivo en un modo especial llamado "accessory". Cuando un dispositivo Android está en modo "accessory" el dispositivo externo actúa como hub usb (proporciona alimentación y ennumera los dispositivos y el dispositivo Android actúa como dispositivo USB. Los accesorios Android USB están diseñados específicamente para conectarse a


P á g i n a | 13

dispositivos Android y utilizan un protocolo simple (Android accessory protocol) que les permite detectar dispositivos Android que soportan modo "accessory".

App Inventor para Android Google anunció en julio de 2010 la disponibilidad de App Inventor para Android, que es un entorno de desarrollo visual Web, para programadores noveles, basado en la biblioteca Open Blocks Java, del MIT. Este entorno proporciona acceso a funciones GPS, acelerómetro y datos de orientación, funciones de teléfono, mensajes de texto, conversión habla a texto, datos de contacto, almacenamiento permanente, y servicios Web, incluyendo inicialmente Amazon y Twitter. Hal Abelson, director de proyecto en el MIT, dijo: "Sólo hemos podido hacerlo porque la arquitectura Android es tan abierta". Después de un año de desarrollo, la herramienta de edición de bloques se ha utilizado para enseñanza a principiantes en ciencias de computación en Harvard, MIT, Wellesley, y en la Universidad de San Francisco, donde el profesor David Wolber, desarrolló un curso de introducción a la ciencia de los ordenadores y un libro de enseñanza para estudiantes que no estudian computación, basado en App Inventor para Android.

HyperNext Android Creator HyperNext Android Creator (HAC) es un sistema de desarrollo de programas dirigido a programadores que empiezan, permitiéndoles crear sus propias aplicaciones sin necesitar conocimientos de Java y del SDK de Android. Está basado en HyperCard, que gestiona el software como una pila de tarjetas en la que sólo una de ellas es visible en un momento dado y por tanto encaja bien en aplicaciones para teléfonos móviles, con una sola ventana disponible a la vez. El lenguaje principal de desallollo se llama simplemente HyperNext y está relacionado con el lenguaje de HyperCards HyperTalk. HyperNext es un intérprete de un lenguaje similar al inglés y tiene muchas funciones para crear aplicaciones Android. Soporta un subconjunto creciente del SDK de Android incluyendo sus propias vesiones de controles gráficos de interfaz de usuario (GUIs) y ejecuta autómaticamente su propio servicio, de forma que las aplicaciones pueden continuar ejecutándose y procesando información, sin estar en el frontal del usuario.

El proyecto Simple


P á g i n a | 14

El objetivo de Simple es ser un lenguaje fácil de aprender para la plataforma Android. Simple es un dialecto de BASIC para Android. Sirve tanto para programadores profesionales como aficionados permitiendo escribir rápidamente aplicaciones que utilizan los componentes de Android. Parecido a Visual Basic 6 de Microsoft, los programas Simple consisten en definiciones de formularios (que contienen componentes) y código (con la lógica del programa). La interacción entre ellos se hace por medio de eventos lanzados por los componentes. La lógica del programa consiste en gestores de eventos, que ejecutan código dependiendo del evento. El proyecto Simple no tiene mucha actividad. La última actualización de código se realizó en agosto de 2009. Existe un producto comercial parecido llamado Basic4android, inspirado en Visual Basic 6 y Microsoft Visual Studio. Este proyecto si tiene actividad y hay una comunidad sólida de programadores.

Android Studio: Se trata del nuevo Entorno de Desarrollo Integrado (IDE, por sus siglas en inglés) para el sistema operativo Android. Este nuevo entorno ofrece nuevas herramientas para desarrolladores Android integradas para el desarrollo de aplicaciones, sustituyendo así a la plataforma Eclipse. Este nuevo entorno ofrece un editor de diseño que permite arrastrar y soltar los componentes en la interfaz de usuario, presentaciones de vista previa de múltiples configuraciones de pantalla, asistentes basados en un plantilla para crear diseños y componentes comunes Android, así como una serie de herramientas para detectar rendimiento, facilidad de uso, compatibilidad de versiones y otros problemas. Además Android Studio incluye integración con Google Cloud Messaging para no tener que abandonar el entorno de desarrollo y la posibilidad de ver en el momento que se realizan los cambios en el diseño de las aplicaciones en diferentes resoluciones. Por el momento, Android Studio está disponible como preview, por lo que Google avisa de que varias características son incompletas o todavía no se han aplicado, con la posibilidad de que se produzcan errores.

RADDroid:


P á g i n a | 15

Su nombre proviene de Rapid Application Development for Android y se trata de una herramienta para desarrolladores que genera un skeleton sofisticado de código para aplicaciones Android a través de una interfaz web. Pero atención, RADDroid es un generador de código, no un generador de aplicaciones ya que el resultado que obtendremos será un projecto Android que podremos importar a Eclipse. RADDroid les permite a los desarrolladores con experiencia ahorrar tiempo a la hora de copiar y pegar el código básico con el que empezamos a crear aplicaciones, y centrar nuestros esfuerzos en funcionalidades más complejas e interesantes. Por otro lado, los desarrolladores que apenas están iniciándose en Android, encontrarán en RADDroid una buena guía para acortar un poco más el tiempo exploratorio dedicado a conocer los componentes básicos de las aplicaciones tanto a nivel gráfico como de funcionalidad. RADDroid genera una gran cantidad de código para los escenarios más comunes que se requieren en una aplicación. Y tal y como lo dije líneas arriba, nos crea el esqueleto de la aplicación por lo que será necesario completar y ampliar el código para incluir la lógica del programa que implemente el propósito principal de la aplicación. Por lo que agregar los datos adicionales, elementos gráficos, recursos, etc. serán las tareas que correrán a nuestro cargo.

DroidDraw para construir interfaces de usuario: Es una aplicación web que nos permitirá diseñar nuestras interfaces usando un editor completamente visual y que incorpora funciones drag & drop para incorporar los elementos que necesitemos. Cabe mencionar que podemos utilizar la versión web de la herramienta o bien, descargarnos la aplicación multiplataforma a nuestra máquina. Una vez que descomprimamos el archivo, bastará con ejecutar el .jar que viene en el directorio para empezar a utilizar el programa.


P á g i n a | 16

La pantalla principal de DroidDraw se encuentra divida en tres partes. Del lado izquierdo tenemos la pantalla que corresponde a la vista previa de la interfaz; y del lado derecho la pantalla se divide en dos módulos, uno superior que muestra los widgets que podemos agregar a la interfaz que vamos a crear y el inferior en el que se generará el código XML del diseño cuando lo hayamos terminado.

ADT Bundle: Es el paquete ADT que proporciona todo lo que necesita para comenzar a desarrollar aplicaciones, incluyendo una versión del IDE de Eclipse con una función de ADT (Android Developer Tools) para optimizar su desarrollo de aplicaciones Android. Si no lo ha hecho, vaya descargar el Android ADT Bundle. (Si ha descargado las herramientas de SDK solamente, para su uso con un IDE existente, en su lugar debe leer la configuración de un IDE existente.)

Eclipse: IDE útil para desarrollo de Android, de código abierto con plugins disponibles para apoyar una amplia variedad de idiomas.

Creación de dispositivos Virtuales: Para este caso utilizaremos la herramienta Xataka para la creación de nuestro dispositivo virtual.


P á g i n a | 17

Creando nuestro dispositivo virtual En el mismo SDK Manager, en el menú izquierdo, podemos ver el apartado de dispositivos virtuales, identificado como “Virtual devices”. Una vez que haga click en ese apartado, veremos una ventana del estilo de la siguiente captura:

En esta ventana se nos listan los dispositivos virtuales ya creados, dándonos información de la versión de Android que usan. A la derecha veremos varios botones que nos ayudarán a gestionar los dispositivos virtuales instalados, pues nos darán opciones como crear un nuevo dispositivo “New…”, editar uno existente “Edit…”, borrar un dispositivo “Delete…”, reparar uno que no funcione bien “Repair…”, información extendida de alguno “Details…” o iniciar un dispositivo “Start…”. Para crear un dispositivo virtual haremos click en el botón “New…”, abriéndose en ese momento una ventana de opciones del dispositivo, que es la que vemos en la captura inferior:


P á g i n a | 18

Aquí podremos elegir todas las opciones referentes a nuestro dispositivo virtual, incluyendo opciones de hardware, así que vamos a listar las opciones de las que disponemos para la configuración de nuestro nuevo dispositivo:  Name: Este será el nombre que recibirá nuestro dispositivo virtual.  Target: En este desplegable podremos elegir la versión de Android que incluirá el dispositivo entre la lista de versiones instaladas.  SDCard: Estas opciones nos permitirán crear un dispositivo con una tarjeta SD de la cantidad de megas que dispongamos. Podremos también seleccionar una imagen para montar, por ejemplo, una tarjeta SD de prueba de un dispositivo que nos da error. Es de remarcar que si seleccionamos crear un SD, no debemos excedernos en la cantidad de memoria, puesto que ésta se reserva en el disco duro y hará que nuestro dispositivo tarde mucho en crearse y luego se ralentice al funcionar.  Snapshot: Seleccionando esta opción permitimos a nuestro dispositivo hacer capturas de su ejecución para que luego se inicie más rápidamente.  Skin: Estas son las opciones referentes a la pantalla que tendrá el dispositivo. Podremos elegir una resolución nativa o personalizarla.


P á g i n a | 19

Hardware: En este apartado elegiremos todo el hardware incluido en el dispositivo virtual, desde soporte para trackball hasta el acelerómetro. Debemos hacer click en “New…” y seleccionar el hardware disponible desde la lista que vemos en la captura inferior.

Una vez terminado el proceso de configuración, crearemos el dispositivo virtual con el botón “Create AVD” que está en la parte inferior. Debemos esperar que se generen los archivos necesarios y se reserve la imagen de la tarjeta SD seleccionada, con lo cual puede tardar un poco de tiempo.

Ejecutando el dispositivo Para ejecutar el dispositivo tendremos varias opciones. La primera de ellas sería entrar en la carpeta “tools” del SDK mediante la línea de comandos, y escribir el comando “emulator.exe -avd nombredeldispositivo”. Otra opción, más sencilla, es entrar en el SDK Manager, ir al menú de dispositivos virtuales, seleccionar uno y pulsar el botón “Start…“, en este caso se nos mostrará la siguiente ventana de configuración del emulador:


P á g i n a | 20

Aquí podremos ver las opciones elegidas para ejecutar el dispositivo virtual, además podremos hacer un “wipe” al dispositivo o cambiar la escala para mostrar la pantalla. Además, podremos seleccionar que se inicie el dispositivo desde la última captura de ejecución o que se inicie desde cero. La primera vez que ejecutemos un dispositivo deberemos esperar a que se inicie, y tenemos que saber que una vez abierto el emulador, éste no irá demasiado fluido. Irá ganando fluidez a medida que abramos opciones o ejecutemos aplicaciones, así que si tarda varios segundos en generar la instrucción que le hayamos descrito, no os precupéis, pues es el funcionamiento normal del emulador.

Emulador de Android La ventana del emulador de Android nos permitirá ver la pantalla a la izqui erda y los controles del dispositivo a la derecha. Se emula un teclado completo y los botones físicos normales de un dispositivo, y además podremos usar el cursor del ratón como si de nuestro dedo se tratase en la pantalla táctil, siempre que hayamos seleccionado un dispositivo con este hardware.


P á g i n a | 21

Con el emulador podremos realizar todas las tareas que se pueden hacer con cualquier dispositivo Android, desde instalar aplicaciones hasta usar el DDMS, ADB, o cualquier otra herramienta del SDK de Android. Es por esto que es tan útil su uso, puesto que nos permite realizar operaciones de un dispositivo, pero sin un dispositivo físico, con lo cual no tendremos que arriesgarnos a estropear un terminal por hacer pruebas. Si somos desarrolladores, podremos probar nuestra aplicación directamente en el emulador, y con el DDMS abierto al mismo tiempo, podremos hacer la depuración de la aplicación sin necesidad de un dispositivo físico. La utilidad menos productiva será quizás la de la curiosidad, y es que Google suele liberar el SDK mucho antes de que las nuevas versiones de Android estén disponibles, con lo cual, desde el emulador podremos navegar por la interfaz de


P á g i n a | 22

la nueva versión y ver un anticipo de sus novedades sin necesidad de que Google libere la propia actualización.

Estructura de un Proyecto Android: Ahora podemos ver en la pestaña Package Explorer la lista de archivos y directorios que ha generado Eclipse.

 /src: en este directorio es donde se almacenarán nuestros archivos de código fuente (archivos .java).  /Android 2.0.1: es la librería de desarrollo de Android (SDK). Podemos ir desplegando el árbol para ver los paquetes y clases que incluye el SDK. Cuando añadamos nuevas librerías o paquetes a nuestro proyecto, aparecerán de la misma forma.  /gen: aquí aparecerán archivos que genera Eclipse de forma automática, como por ejemplo el archivo R.java. Estos archivos no deberemos editarlos, ya que será Eclipse el que se encargará de modificarlos automáticamente según otros parámetros del proyecto.


P á g i n a | 23

 /assets: es un directorio para guardar recursos que utilice tu aplicación. Para acceder a los recursos de este directorio necesitarás usar la clase AssetManager para leer los datos como un stream de bytes, por lo que es preferible utilizar el directorio /res ya que el acceso a los archivos es mucho más sencillo.  /res: es el directorio principal de recursos (resources). Aquí guardaremos imágenes o archivos multimedia que utilice nuestra aplicación. Los recursos colocados en este directorio son fácilmente accesibles desde la clase R.  /res/drawable-?dpi: es el directorio de recursos gráficos o imágenes que utilizará nuestra aplicación. Tiene tres subdirectorios: drawable-hdpi, drawable-mdpi y drawable-ldpi, en el que guardaremos las imágenes dependiendo de la densidad de puntos por pulgada que tenga el dispositivo en el que se ejecute la aplicación. Puedes consultar la sección Supporting Multiple Screens de la guía de desarrollo para Android para comprender mejor cómo programar para distintos tamaños de pantalla.  /res/layout: en Android podemos debemos separar el código de la aplicación de la interfaz gráfica. En este directorio es donde colocaremos los archivos xml que definen las vistas que utilizará la aplicación. Desde el código de la aplicación le indicaremos el archivo xml que queremos que use en cada momento, de forma que nos facilitará mucho modificar el código sin tener que tocar nada del entorno gráfico, y viceversa.  /res/values: al igual que separamos el código de la aplicación de la interfaz gráfica mediante vistas, conviene hacer lo mismo con cadenas de texto, arrays, paleta de colores que usará la interfaz… Este apartado cobra importancia en la localización de nuestra aplicación. Por ejemplo, podremos definir un archivo strings.xml en /res/drawable-es/ y otro en /res/drawable/. El primero se utilizará automáticamente si el usuario tiene configurado el terminal en el idioma español, mientras que en el resto de casos se utilizará el archivo que se encuentra en /res/drawable/.  AndroidManifest.xml: es el archivo de configuración de nuestra aplicación. En él definiremos “qué puede hacer nuestra aplicación”, es decir, informaremos al sistema de que nuestra aplicación puede abrir archivos mp3, abrir enlaces http o que es capaz de manejar las llamadas telefónicas que recibamos. En este archivo también indicaremos las actividades o servicios que ejecutará nuestra aplicación y los permisos especiales que necesita utilizar en el caso de que quiera acceder a recursos compartidos del sistema, como el acceso a la lista de contactos, uso del GPS, o la posibilidad de enviar mensajes SMS.  default.properties: es un fichero que genera automáticamente Eclipse y del que no deberemos preocuparnos inicialmente.


P á g i n a | 24

Pasos para la creación de un proyecto Un proyecto Android contiene todos los archivos que componen tu aplicación. Las herramientas del SDK facilitan crear un nuevo proyecto Android con un conjunto de ficheros y carpetas por defecto. Esta lección muestra cómo crear un nuevo proyecto usando Eclipse (con el plugin ADT) o las herramientas del SDK desde línea de comandos. Nota: Ya deberías tener el SDK de Android instalado, y si estás usando Eclipse, también deberías haber instalado el plugin ADT (versión 21.0.0 o superior). Si no es el caso, sigue la guía Instalando el SDK de Android antes de comenzar esta lección.

Crear un proyecto con Eclipse: 1. Haz clic sobre el botón New (Nuevo) de la barra de herramientas. 2. En la ventana que se mostrará, abre la carpeta Android, selecciona Android Application Project (Proyecto de Aplicación Android), y haz clic sobre el botón Next (Siguiente).

3. Rellena el formulario que aparecerá: Application Name (Nombre de la aplicación) es el nombre de la aplicación tal y como se mostrará a los usuarios. Para este proyecto, utiliza "My First App" (Mi Primera Aplicación)  Project Name (Nombre de proyecto) es el nombre del directorio que se creará para tu proyecto y el nombre con el que se le hará referencia en Eclipse.


P á g i n a | 25

 Package Name (Nombre de paquete) es el nombre del paquete a utilizar para tu aplicación (siguiendo las mismas normas que los paquetes en el lenguaje de programación Java). Tu nombre de paquete debería ser único, distinto del resto de paquetes instalados en el sistema Android. Por esta razón, normalmente es buena idea utilizar un nombre que comience con el dominio inverso de tu organización o entidad publicadora. Para este proyecto, puedes usar algo como "com.example.myfirstapp". Sin embargo, no puedes publicar tu aplicación en Google Play usando el espacio de nombres "com.example".  Minimum Required SDK (SDK mínimo requerido) es la versión mínima de Android que soporta tu aplicación, especificada usando los Niveles API. Para que tu aplicación funcione en el mayor número de dispositivos posible, deberías establecer este valor a la mínima versión que te permita implementar las características principales de tu aplicación. Si hay alguna funcionalidad que sólo es posible implementar en versiones nuevas de Android y no es una funcionalidad crítica, puedes habilitarla sólo si se está ejecutando una versión que la soporte (tal y como se explica en Soportando distintas versiones de la plataforma). Para este ejemplo, deja esta opción en su valor por defecto.  Target SDK (SDK objetivo) es la versión más moderna de Android con la que has probado tu aplicación (de nuevo usando el Nivel API). Cuando salga una nueva versión de Android, deberías comprobar que tu aplicación sigue funcionando en la nueva versión y actualizar este valor para que coincida con el último nivel API para sacar provecho de las nuevas funcionalidades de la plataforma.  Compile With (Compilar con) es la versión de la plataforma contra la que quieres compilar tu aplicación. Por defecto, este valor se establece a la última versión de Android disponible en tu SDK. (Debería ser Android 4.1 o superior; si esta versión no está disponible, debes instalarla usando el Gestor del SDK). Seleccionar la última versión disponible te permite soportar versiones anteriores al tiempo que habilitas nuevas características y optimizas tu aplicación para una gran experiencia de usuario en los dispositivos más modernos.  Theme (Tema) especifica el estilo de interfaz de usuario Android que aplicar a tu aplicación. No es necesario que modifiques este valor. Haz clic en Next. 4. En la siguiente pantalla de configuración del proyecto, deja los valores por defecto y haz clic en Next.


P á g i n a | 26

5. La siguiente pantalla puede ayudarte a crear un icono para el lanzador de tu aplicación. Puedes personalizar tu icono de distintas maneras y la herramienta generará un icono para todas las densidades de pantalla. Antes de publicar tu aplicación, deberías asegurarte de que tu icono sigue las especificaciones definidas en la guía de diseño de Iconografía. Haz clic en Next. 6. Ahora puedes seleccionar una plantilla de actividad con la que empezar a construir tu aplicación. Para este proyecto, selecciona BlankActivity (actividad vacía) y haz clic en Next. 7. Mantén todos los detalles de la actividad en sus valores por defecto y haz clic en Finish (Terminar). Ya hemos terminado de configurar tu proyecto Android con algunos archivos por defecto y estás listo para empezar a construir tu primera aplicación.

Controles para Android: CONTROLADORES ANDROID

Input Controls


P รก g i n a | 27

Buttons


P รก g i n a | 28

Text Fields


P รก g i n a | 29

Password <EditText android:layout_height="wrap_content" android:gravity="center" android:password="true" android:layout_width="fill_parent" android:id="@+id/password" android:hint="password" android:maxLines="1"> </EditText>


P รก g i n a | 30

Checkboxes


P รก g i n a | 31

Radio Buttons


P รก g i n a | 32

Toggle Buttons

Rating Bar <RatingBar android:id="@+id/ratingBar1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_alignParentLeft="true"


P รก g i n a | 33

android:layout_alignParentTop="true" android:layout_marginLeft="22dp" android:layout_marginTop="28dp" />

Spinners


P รก g i n a | 34

Pickers

TIME PICKER


P รก g i n a | 35

DATE PICKER


P รก g i n a | 36

Analogclock and Digitalclock <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:background="@android:color/background_dark" android:orientation="vertical" > <TextView android:id="@+id/textView1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="center" android:layout_marginTop="5dp" android:text="Analog Clock" android:textColor="@android:color/white" />


P รก g i n a | 37

<AnalogClock android:id="@+id/analogClock1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="center" />

<TextView android:id="@+id/textView2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="center" android:layout_marginTop="30dp" android:text="Digital Clock" android:textColor="@android:color/white" /> <DigitalClock android:id="@+id/digitalClock1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_gravity="center" android:layout_marginTop="5dp" android:background="@android:color/darker_gray" android:text="DigitalClock" />


P รก g i n a | 38

</LinearLayout>

Progress Bar <?xml version="1.0" encoding="utf-8"?> <resources> <string name="hello">ProgressBarExample</string> <string name="app_name">Threaded Progress Bar Example</string> <string name="Button01Text">Show Spinner Progress Bar</string> <string name="Button02Text">Show Horizontal Progress Bar</string> </resources>

<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" > <Button android:text="@string/Button01Text" android:id="@+id/Button01" android:layout_width="fill_parent" android:layout_height="wrap_content"> </Button> <Button android:text="@string/Button02Text" android:id="@+id/Button02"


P รก g i n a | 39

android:layout_width="fill_parent" android:layout_height="wrap_content"> </Button> </LinearLayout>

Alert Dialog


P รก g i n a | 40

Prompt Dialog <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <Button android:id="@+id/buttonPrompt" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Show Prompt Dialog" /> <EditText


P รก g i n a | 41

android:id="@+id/editTextResult" android:layout_width="match_parent" android:layout_height="wrap_content" > </EditText> </LinearLayout>

Custom Dialog


P รก g i n a | 42


P รก g i n a | 43

Toasts


P รก g i n a | 44

View Image <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent"> <ImageView android:layout_width="match_parent" android:layout_height="wrap_content" android:contentDescription="@string/banner_alt"


P รก g i n a | 45

android:src="@drawable/banner_portrait" /> </LinearLayout>

ImageButton <?xml version="1.0" encoding="utf-8"?> <selector xmlns:android="http://schemas.android.com/apk/res/android"> <item android:state_pressed="true" android:drawable="@drawable/button_pressed" /> <!-- pressed -> <item android:state_focused="true" android:drawable="@drawable/button_focused" /> <!-- focused -> <item android:drawable="@drawable/button_normal" /> <!-- default --> </selector>

ImageButton Selector <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" > <Button android:id="@+id/button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:background="@drawable/mybutton" />


P รก g i n a | 46

</LinearLayout>

LinearLayout


P รก g i n a | 47


P รก g i n a | 48

RelativeLayout


P รก g i n a | 49


P รก g i n a | 50

TableLayout

<?xml version="1.0" encoding="utf-8"?> <TableLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:stretchColumns="1"> <TableRow> <TextView android:text="@string/table_layout_4_open" android:padding="3dip" /> <TextView android:text="@string/table_layout_4_open_shortcut" android:gravity="right" android:padding="3dip" /> </TableRow> <TableRow> <TextView android:text="@string/table_layout_4_save" android:padding="3dip" /> <TextView android:text="@string/table_layout_4_save_shortcut" android:gravity="right" android:padding="3dip" /> </TableRow> </TableLayout>


P รก g i n a | 51

ListView

public class ListViewLoader extends ListActivity implements LoaderManager.LoaderCallbacks<Cursor> { // This is the Adapter being used to display the list's data SimpleCursorAdapter mAdapter; // These are the Contacts rows that we will retrieve static final String[] PROJECTION = new String[] {ContactsContract.Data._ID, ContactsContract.Data.DISPLAY_NAME}; // This is the select criteria static final String SELECTION = "((" + ContactsContract.Data.DISPLAY_NAME + " NOTNULL) AND (" + ContactsContract.Data.DISPLAY_NAME + " != '' ))"; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Create a progress bar to display while the list loads ProgressBar progressBar = new ProgressBar(this);


P รก g i n a | 52

progressBar.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.CENTER)); progressBar.setIndeterminate(true); getListView().setEmptyView(progressBar); // Must add the progress bar to the root of the layout ViewGroup root = (ViewGroup) findViewById(android.R.id.content); root.addView(progressBar); // For the cursor adapter, specify which columns go into which views String[] fromColumns = {ContactsContract.Data.DISPLAY_NAME}; int[] toViews = {android.R.id.text1}; // The TextView in simple_list_item_1 // Create an empty adapter we will use to display the loaded data. // We pass null for the cursor, then update it in onLoadFinished() mAdapter = new SimpleCursorAdapter(this, android.R.layout.simple_list_item_1, null, fromColumns, toViews, 0); setListAdapter(mAdapter); // Prepare the loader. Either re-connect with an existing one, // or start a new one. getLoaderManager().initLoader(0, null, this); } // Called when a new Loader needs to be created public Loader<Cursor> onCreateLoader(int id, Bundle args) { // Now create and return a CursorLoader that will take care of // creating a Cursor for the data being displayed. return new CursorLoader(this, ContactsContract.Data.CONTENT_URI, PROJECTION, SELECTION, null, null); } // Called when a previously created loader has finished loading public void onLoadFinished(Loader<Cursor> loader, Cursor data) { // Swap the new cursor in. (The framework will take care of closing the // old cursor once we return.) mAdapter.swapCursor(data);


P รก g i n a | 53

} // Called when a previously created loader is reset, making the data unavailable public void onLoaderReset(Loader<Cursor> loader) { // This is called when the last Cursor provided to onLoadFinished() // above is about to be closed. We need to make sure we are no // longer using it. mAdapter.swapCursor(null); } @Override public void onListItemClick(ListView l, View v, int position, long id) { // Do something when a list item is clicked } }

GridView

<?xml version="1.0" encoding="utf-8"?> <GridView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/gridview" android:layout_width="fill_parent"


P รก g i n a | 54

android:layout_height="fill_parent" android:columnWidth="90dp" android:numColumns="auto_fit" android:verticalSpacing="10dp" android:horizontalSpacing="10dp" android:stretchMode="columnWidth" android:gravity="center" />

WebView <?xml version="1.0" encoding="utf-8"?> <WebView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/webview" android:layout_width="fill_parent" android:layout_height="fill_parent" />

Activities <manifest ... > <application ... > <activity android:name=".ExampleActivity" /> ... </application ... > ... </manifest > <activity android:name=".ExampleActivity" android:icon="@drawable/app_icon"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> Intent intent = new Intent(this, SignInActivity.class); startActivity(intent);


P รก g i n a | 55

Intent intent = new Intent(Intent.ACTION_SEND); intent.putExtra(Intent.EXTRA_EMAIL, recipientArray); startActivity(intent);


P ĂĄ g i n a | 56

BibliografĂ­a 1. http://mundogeek.net/android/primera-aplicacion/crear-proyecto.htm 2. http://www.weterede.com/2010/10/estructura-de-un-proyecto-android-eneclipse/ 3. http://www.xatakandroid.com/tutoriales/usando-el-sdk-dispositivosvirtuales-y-emulador

Desarrollo de aplicaciones android  
Desarrollo de aplicaciones android  
Advertisement