INSTITUTO TECNOLÓGICO SUPERIOR DE LA

REGIÓN SIERRA

TRABAJO DE DESARROLLO MOVIL

MATERIA:
Dispositivos moviles

DOCENTE:
Jose De Jesus Lenin Valencia Cruz

NOMBRE DE LOS ALUMNO:

Jose Gerardo Sanchez Alvarado

SEMESTRE:
8to

GRUPO:
B

TURNO:
Vespertino

CARRERA:
Ing.Informatica

FECHA:
Tepa, tabasco a 18 de mayo del 2018
Las aplicaciones Android se desarrollan usando Java, iOS usa Objetive C como lenguaje de
desarrollo y Symbiam usa C++...

Esto implica la necesidad de manejar correctamente muchos lenguajes de programación (muy

diferentes) para desarrollar una sola aplicación. Además, cada plataforma requiere del uso de
un IDE diferente.

¿Qué es lo ideal? Desarrollar para todas las plataformas usando un único código, así las
aplicaciones abarcan un número mayor de posibles usuarios y todo ello con un ahorro de
esfuerzo considerable.

¿Hay una forma de desarrollar aplicaciones con una tecnología única?

PhoneGAP es un frameworks que funciona como una solución multi-plataforma y que

permite usar las últimas tecnologías web: HTML5, CSS3 y JavaScript.

Los desarrolladores web pueden desarrollar aplicaciones nativas para dispositivos móviles
usando tecnologías familiares y fáciles de usar.

Con PhoneGAP, con un solo código cuya lógica de programación está sustentada en el
lenguaje de programación web JavaScript, obtendremos la aplicación para varias plataformas
móviles.
 INTRODUCCIÓN

PhoneGAP es un frameworks para el desarrollo de aplicaciones móviles. Actualmente

pertenece a Adobe System.

PhoneGAP permite a los programadores desarrollar aplicaciones para dispositivos móviles

utilizando Herramientas genéricas tales como JavaScript, HTML5 y CSS3.

Las aplicaciones resultantes son híbridas, es decir que no son realmente aplicaciones nativas
al dispositivo (ya que el renderizado es realizado mediante vistas web). Sin embargo, no se
tratan tampoco de aplicaciones web puras.

Son empaquetadas para ser desplegadas en el dispositivo trabajando con el API del sistema
nativo.

PhoneGAP maneja Apis que permiten tener acceso a elementos como el acelerómetro,
cámara, contactos en el dispositivo, red, almacenamiento, notificaciones, etc.

PhoneGAP es compatible con frameworks de desarrollo web móvil: JQuery Mobile, Sencha
Touch, Dojo, jQTouch, SprountCore, Glovebox, XUI, inscroll.
 DATOS SOBRE PHONEGAP - CORDOVA

Actualmente esté framework soporta:

• Android
• iOS
• Windows Phone
• BlackBerry OS
• Web OS
• Symbiam
• Bada

Podemos ver el soporte actual para cada una de estas plataformas:

phoneGAP es completamente libre. Se puede descargar de la página web oficial.

Además, disponemos de una sección para desarrolladores con instrucciones para comenzar a
usarlo.

Aunque PhoneGAP es el más conocido, existen otros frameworks similares:

• Appcelerator Titanium: http://www.appcelerator.com/

• Mobil: http://www.appcelerator.com/
• Sencha Touch: http://www.sencha.com/products/touch/

DESCARGAR PHONEGAP

Al descargar phoneGAP de su sitio web, obtenemos un archivo. Zip.

Al descomprimirlo obtenemos una carpeta para cada sistema operativo, con una librería
JavaScript y otra en el lenguaje nativo para comunicar la aplicación web con el dispositivo.

Podemos descargar la última versión disponible del frameworks de:

http://phonegap.com/download/

Actualmente la versión más nueva es la 2.8.0.

 CREAR LA PRIMERA APLICACIÓN (PROYECTO ANDROID)

En http://phonegap.com/start podemos encontrar tutoriales detallados para comenzar a hacer

aplicaciones phoneGAP para cada sistema operativo compatible: iOS, Android, BlackBerry
OS, Windows Phone, Web OS, Bada y Symbiam.

A continuación, veamos los pasos necesarios para crear un proyecto phoneGAP para Android
con Eclipse y el plugin ADT instalados.

Iniciar Eclipse y crear un nuevo proyecto a través del menú File > New > Project

Eclipse nos guiará en el proceso de crear la aplicación. Básicamente debemos rellenar las
diferentes ventanas como mostramos a continuación.
Crearemos un proyecto Android nuevo:

A continuación, indicamos el nombre del proyecto:

Pulsamos “siguiente” en los siguientes cuadros de diálogo:

Una vez creado, estaremos en la pantalla principal de Eclipse, y veremos a la izquierda el
explorador de proyectos.

Allí vamos a abrir el proyecto recién creado y pulsando con el botón derecho, vamos a crear
una carpeta /assets/www y otra /libs (si no existen).
Debemos copiar en /assets/www el archivo cordova-2.8.0.js y en /libs el archivo cordova-
2.8.0.jar. Ambos archivos están en la carpeta obtenida al descomprimir el paquete
descargado.

Sólo tenemos que arrastrar desde el explorador de ficheros del sistema operativo los archivos
indicados sobre la carpeta que acabamos de crear en nuestro proyecto.

Desplegar la carpeta /src del proyecto para modificar el archivo Java y dejarlo como sigue
(hacemos doble clic en él para cargarlo en el editor):
Y hacer lo propio con el archivo index.html que tendremos en la carpeta www en assets:

Ya podemos pasar a ejecutar el proyecto en el emulador. Seleccionar el menú Run > Run y
en la ventanita, seleccionar Android Application.
Durante la compilación veremos abajo, en la Consola los mensajes de avance. Si todo ha ido
bien, veremos un mensaje en el que se indica que se ha lanzado el Activity (la pantalla de la
aplicación):
Al mismo tiempo que se realiza la compilación, se lanzará el emulador, que arrancará
Android como lo hace cualquier dispositivo físico:

Una vez haya arrancado, nos mostrará la aplicación en ejecución. En nuestro caso veremos
la pantalla en la que mostramos el mensaje “Holita vecino”. Si hubiéramos incluido enlaces
a otras páginas, imágenes o elementos de formulario, podríamos interaccionar con la
aplicación:
 DESCRIPCIÓN DE LAS APIS DE PHONEGAP

Como primera aplicación hemos hecho algo muy sencillo, pero phoneGAP ofrece varias
APIS para desarrollar aplicaciones que tengan acceso al hardware del dispositivo móvil:

• Acelerómetro: brinda acceso al acelerómetro del dispositivo si es que cuenta con

él.
• Camera: Brinda acceso a la aplicación de la cámara para tomar una foto u
obtenerla de la galería.
• Capture: Brinda acceso a aplicaciones de capturas de audio y video.
• Compas: Esta API es útil para hacer verificación en cambio de la orientación del
dispositivo, también depende del hardware del dispositivo.
• Connection: Útil para trabajar con las conexiones de red que cuenta el
dispositivo, desde redes Wifi, redes 3G, redes 4G entre otras.
• Contacts: proporciona acceso a los contactos almacenados en el dispositivo.
• Device: Con esta se pueden obtener datos del dispositivo como el sistema
operativo, el nombre y algunos otros datos relevantes.
 • Eventos: con esta APIS es posible manejar eventos de teclas físicas del
dispositivo, además de manejar los diferentes eventos generados en el ciclo de
vida de una aplicación.
• File: Su implementación facilita el acceso a los archivos del dispositivo, con esta
API se puede crear, editar y leer archivos binarios.
• Geolocation: Útil para obtener la posición geográfica del dispositivo, ya bien sea
a través de redes o del GPS satelital si cuenta la cuenta el dispositivo con uno.
• Media: proporciona acceso a reproductores multimedia como sonido y video.
• Notication: además de ser útil para crear cuadros de diálogos como alertas
nativas del sistema, también brinda acceso al vibrador si el dispositivo lo posee.
• Storage: Facilita el uso de base de datos basadas en el estándar de W3C y el uso
de localStorage.

Todas las APIs se encuentran detalladas, con ejemplos de uso, en la web:

http://docs.phonegap.com/en/2.8.0/index.html

PHONEGAP BUILD: COMPILADOR EN LA NUBE

Debido a lo complicado que resulta hacer todas las configuraciones necesarias para hacer uso
de phoneGAP en diferentes plataformas y sistemas de desarrollo, disponemos de un
compilador en la nube que nos facilitará la compilación de nuestras aplicaciones.

Por ejemplo, el entorno de desarrollo Windows Phone solo se puede ejecutar en el sistema
operativo Windows, mientras que para desarrollar para iOS es necesario un sistema operativo
OS X de Apple.

El compilador en la nube recibe el nombre de PhoneGAP Build y se encuentra en la siguiente

web http://build.phonegap.com/

Para usarlo debemos crear una cuenta:

Desarrollar (gratis).
Starter ($12 mensuales).
Team ($30 mensuales).
Corporativa ($90 mensuales).
Cada uno de esos tipos nos permite mantener y compilar diferente número de aplicaciones
(privadas y públicas).

Aunque phoneGAP se puede usar en siete plataformas, phoneGAP Build solo compila para
seis: iOS, Android, BlackBerry OS, Symbiam, Web OS y Windows Phone.

El modo de funcionamiento es sencillo: sólo tenemos que subir el código de nuestra

aplicación en forma de archivo. Zip teniendo en cuenta que el inicio de nuestra aplicación
debe ser el archivo index.html

phoneGAP Build nos avisa de posibles errores si los hay, de no ser así, obtenemos un paquete
de instalación para cada uno de los sistemas operativos móviles soportados.

BIBLIOGRAFÍA Y OTROS RECURSOS EN INTERNET

http://www.phonegap.com

http://www.maestrosdelweb.com/editorial/aplicacion-nativa-phonegap
http://www.desarrolloweb.com/manuales/aplicaciones-moviles-phonegap.html
http://www.adobe.com/devnet/html5/articles/getting-started-with-phonegap-in-eclipse-
forandroid.html
Como instalar el SDK y los componentes de Android studio.
Para poder trabajar sin problemas con Android Studio y poder aprovechar al máximo
sus funciones tanto a nivel de programación como a nivel de virtualización es
necesario instalar los componentes y los SDK correspondientes en nuestro ordenador
de manera que el sistema sea capaz de disponer de todos los recursos del sistema
operativo de Google siempre que los necesite.
Una vez que hemos instalado ya Android Studio en nuestro ordenador lo ejecutamos
y lo primero que veremos será el asistente principal de la Herramienta

Desde aquí podemos crear nuevos proyectos, abrir proyectos ya existentes y otras
opciones, aunque la que nos interesa antes de empezar con otras configuraciones la
de “Configure”.
Pulsamos sobre ella y llegaremos a una nueva ventana desde donde podemos cambiar los
ajustes generales de Android Studio, así como configurar los plugin y abrir el administrador
del SDK. Esta última opción es la que debemos ejecutar para poder instalar nuevos SDK y
componentes para la suite de desarrollo, por ello debemos pulsar sobre “SDK Manager”.

Se nos abrirá una ventana nueva con una completa lista de componentes y extensiones
que podemos instalar y desinstalar de nuestra suite Android studio.

Por defecto al instalar esta herramienta

de desarrollo se instalarán una serie de elementos base que, aunque pueden funcionar,
es posible que necesitemos elementos adicionales para su correcto funcionamiento,
por ejemplo, desarrollar para versiones anteriores a Android 5 o emularlas.
Podemos ver 3 elementos principales en esta ventana
TOOLS: Desde este apartado instalaremos las herramientas seleccionadas con el
SDK, necesarias para el desarrollo.

Android x.x (API X): Desde aquí instalaremos los componentes de la API
necesarios para compilar las aplicaciones para las versiones correspondientes.
Igualmente instalaremos las máquinas virtuales de dicha versión de Android,
necesarias para poder montar una máquina virtual de Android.
Desde aquí podemos instalar todas las API desarrolladas para el sistema operativo
Android, desde la API 3 correspondiente a Android 1.5) hasta la actual API 21
(correspondiente a Android 5.0.1).

Extras: Desde este apartado podemos elegir si instalar o desinstalar componentes

adicionales, por ejemplo, los servicios de Google Play, los drivers de aceleración para
máquinas x86 o los controladores USB de desarrollo.
Debemos aceptar los términos de licencia antes de poder empezar con la descarga.

El proceso puede durar algún tiempo según el tamaño y el número de los componentes.
Una vez finalice el proceso los
elementos estarán en nuestro disco
duro, dentro de la carpeta SDK que
hayamos configurado durante la
instalación, y listos para ser utilizados.

La definición de un Android Virtual Device (AVD) te permite definir las características de

un teléfono Android, una Tablet, o un dispositivo Android Wear o Android TV que desees
simular en Android Emulador
(https://developer.android.com/tools/devices/emulator.html?hl=es-419). El Administrador
de AVD te permite crear y administrar AVD fácilmente.
Para probar tu app de manera efectiva, debes crear un AVD que modele cada tipo de
dispositivo que tu app pueda admitir. Por ejemplo, te recomendamos crear un AVD para cada
nivel de API igual o superior al valor que especificaste para tu minSdkVersion
(https://developer.android.com/guide/topics/manifest/uses-sdk-element.html?hl=es-419).
Al probar con niveles API superiores a los que necesita tu app, garantizas la compatibilidad
con versiones posteriores cuando los usuarios descargan actualizaciones de sistema.

Acerca de los AVD

Un AVD contiene un perfil de hardware, una imagen de sistema, un área de almacenamiento
y una máscara, entre otras propiedades.
El perfil de hardware define las características de un dispositivo cuando se envía desde la
fábrica. El Administrador de AVD viene cargado previamente con determinados perfiles de
hardware, como dispositivos de teléfono Nexus, y puedes definir e importar perfiles de
hardware cuando sea necesario. Puedes sobrescribir algunas configuraciones en tu AVD, si
es necesario.
El Administrador de AVD te permite elegir una imagen de sistema para tu AVD
proporcionando recomendaciones: También te permite descargar imágenes de sistema,
algunas con bibliotecas de complementos como las API de Google, que puede necesitar tu
app. Ten en cuenta que las imágenes de sistema x86 se ejecutan de manera más rápida en el
emulador.
El AVD tiene un área dedicada al almacenamiento en tu equipo de desarrollo. Almacena los
datos del usuario del dispositivo, como las apps y las configuraciones instaladas, así como
también una tarjeta SD emulada.
Una máscara de emulador especifica la apariencia de un dispositivo. El Administrador de
AVD proporciona algunas máscaras predefinidas. También puedes definir tus propias
máscaras o usar máscaras proporcionadas por terceros.
Al igual que con un dispositivo real, para que las apps usen determinadas funciones definidas
en un AVD, como la cámara, este debe tener la correspondiente configuración <usesfeature>
(https://developer.android.com/guide/topics/manifest/uses-feature-element.html?hl=es-419)
en el manifiesto de app.

Visualizar y administrar tus AVD

El Administrador de AVD te permite administrar todos tus AVD en un solo sitio.

Para ejecutar el Administrador de AVD:
En Android Studio, selecciona Tools > Android > AVD Manager.

Haz click en el Administrador de AVD en la Barra de Herramientas.

Aparece el Administrador de AVD.

Muestra cualquier AVD que hayas definido. Cuando instales Android Studio por primera
vez, crea un AVD. Si definiste los AVD para Android Emulador 24.0.x o versiones
anteriores, debes volver a crearlos.
Desde esta página puedes:

definir un AVD (#createavd) o perfil de hardware (#createhp) nuevos;

editar un AVD (#workingavd) o perfil de hardware (#workinghp)
existentes; borrar un AVD (#workingavd) o perfil de hardware
(#workinghp);

importar o exportar (#importexporthp) definiciones de perfiles de hardware; ejecutar

(#emulador) un AVD para iniciar el emulador; detener (#emulador) un emulador;
borrar (#emulador) datos y comenzar de nuevo, desde el mismo estado en que
ejecutaste el emulador por primera vez;
mostrar (#workingavd) los archivos .ini e .img asociados del AVD; visualizar
(#workingavd) los detalles de configuración de AVD que puedes incluir en
cualquier informe de errores para el equipo de Android Studio.

Crear un AVD
Puedes crear un AVD nuevo desde el comienzo o duplicar un AVD (#copyavd) y cambiar
algunas propiedades.
Para crear un AVD nuevo:

1. Desde la página Your Virtual Devices (#viewing) del Administrador de AVD, haz
clic en Create Virtual Device.

Opcionalmente, ejecuta tu app

(https://developer.android.com/studio/run/index.html?hl=es-419#RunningApp)
desde Android Studio. En el diálogo Select Deployment Target, haz click en Create
New Emulator.
2. Selecciona un perfil de hardware y haz clic en Next.

Si no ves el perfil de hardware que deseas, puedes crear (#createhp) o importar

(#importexporthp) un perfil de hardware.
Aparecerá la página de System Imagen.
3. Selecciona la imagen del sistema para un nivel de API particular y luego haz clic en
Next.

En la pestaña Recommended aparecen listas de imágenes recomendadas del sistema. En

las otras pestañas se incluye una lista más completa. En el panel derecho se describe la
imagen de sistema seleccionada. Las imágenes x86 son las que se ejecutan más rápido en
el emulador.
Si visualizas Down load junto a la imagen de sistema, debes hacer clic en la opción para
descargar la imagen de sistema. Debes estar conectado a Internet para descargarla.
El nivel de API del dispositivo de destino es importante, ya que tu app no podrá ejecutarse
en una imagen de sistema con un nivel de API inferior al que se necesita en tu app, según
se especifica en el atributo minSdkVersion.
Si tu app declara un elemento <uses-library>
(https://developer.android.com/guide/topics/manifest/uses-library-element.html?hl=es-
419) en el archivo de manifiesto, requerirá una imagen de sistema en la cual se encuentre
esta biblioteca. Si deseas ejecutar tu app en un emulador, crea un AVD que incluya la
biblioteca obligatoria. Para hacerlo, probablemente debas usar un componente
complementario para la plataforma de AVD; por ejemplo, el complemento de las API de
Google contiene la biblioteca de Google Maps.
Aparecerá la página Verify Configuración.
 Modifica las propiedades de AVD (#avdproperties) según sea necesario y luego haz clic
en Finish.
Haz clic en Show Advanced Settings para mostrar más configuraciones, como la
máscara.
El nuevo AVD aparecerá en la página Your Virtual Devices o en el diálogo Select
Deployment Target.
Para crear un AVD a partir de una copia:

1. Desde la página Your Virtual Devices (#viewing) del Administrador de AVD, haz
clic con el botón secundario en un AVD y selecciona Duplícate.

O haz clic en Menú y selecciona Duplícate.

Aparecerá la página Verify Configuration (#verifyconfigpage).

2. Haz clic en Change o Previos si debes realizar modificaciones en las páginas System
Image (#systemimagepage) y Select Hardware (#selecthardwarepage).

3. Realiza tus modificaciones y luego haz clic en Finish.

El AVD aparece en la página Your Virtual Devices.

Crear un perfil de hardware

El Administrador de AVD proporciona perfiles de hardware predefinidos para dispositivos
comunes a fin de que puedas agregarlos fácilmente a tus definiciones de AVD. Si debes
definir un dispositivo diferente, puedes crear un perfil de hardware nuevo. Puedes establecer
un perfil de hardware nuevo desde el principio, o copiar un perfil de hardware (#copyavd)
para empezar. No es posible editar los perfiles de hardware precargados.
Para crear un perfil de hardware nuevo desde el comienzo:

1. En la página Select Hardware (#selecthardwarepage), haz click en New Hardware

Profile.

2. En la página Configure Hardware Profile, modifica las propiedades del perfil de

hardware (#hpproperties) según sea necesario.

3. Haz click en Finish.

 Tu perfil de hardware nuevo aparecerá en la página Select Hardware. Opcionalmente,
puedes crear un AVD (#createavd) que use el perfil de hardware haciendo clic en
Next. También puedes hacer clic en Cancel para regresar a la página Your Virtual
Devices o al diálogo Select Deployment Target.
Para crear un perfil de hardware a partir de una copia:

1. En la página Select Hardware (#selecthardwarepage), selecciona un perfil de

hardware y haz clic en Clone Device.

También puedes hacer clic con el botón secundario en un perfil de hardware y

seleccionar Clone.

2. En la página Configure Hardware Profile, modifica las propiedades del perfil de

hardware (#hpproperties) según sea necesario.

3. Haz click en Finish.

Tu perfil de hardware nuevo aparecerá en la página Select Hardware. Opcionalmente,

puedes crear un AVD (#createavd) que use el perfil de hardware haciendo clic en
Next. También puedes hacer clic en Cancel para regresar a la página Your Virtual
Devices o al diálogo Select Deployment Target.

Ejecutar y detener un emulador, y borrar datos

Desde la página Your Virtual Devices (#viewing), puedes realizar las siguientes operaciones
en un emulador:
Para ejecutar un emulador que use un AVD, haz doble clic en el AVD. También puedes
hacer haz clic en Run .
Para detener un emulador de ejecución, haz clic con el botón secundario en un AVD y
selecciona Stop. También puedes hacer clic en Menú y seleccionar Stop.
Para borrar los datos de un emulador y regresar al mismo estado que se estableció al
principio, haz clic con el botón secundario en un AVD y selecciona Wipe Data.
También puedes hacer clic en Menú y seleccionar Wipe Data.
 Importar y exportar perfiles de hardware.

Desde la página Select Hardware (#selecthardwarepage), puedes importar y exportar perfiles

de hardware:
Para importar un perfil de hardware, haz clic en Import Hardware Profiles y
selecciona el archivo XML que contiene la definición en tu computadora.
Para exportar un perfil de hardware, haz clic con el botón secundario en este y
selecciona Export. Especifica la ubicación en la que desees almacenar el archivo
XML que contenga la definición.

Genymotion es una gran opción a tener en cuenta. Está basada en máquinas virtuales
sobre Virtual Box y tiene una rapidez de arranque e instalación muy buena. Como
inconveniente, podemos decir que la versión gratuita realiza casi todo lo necesario en
el testeo de aplicaciones, pero se reserva algunas funcionalidades para la versión de
pago como por ejemplo la simulación de llamadas entrantes.
Es muy recomendable probar esta herramienta indispensable para probar apps en
Android. Además, si disponemos de un equipo que no disponga de toda la memoria
RAM que quisiéramos para desarrollar en Android puede ser una alternativa muy
buena al emulador integrado en Android Studio.
 Pasemos a la instalación de Genymotion. Es muy sencillo:

1. Nos registramos en la página web de Genymotion, nos hará faltar para poder
hacer uso del programa.

2. Accedemos a la descarga en la página de Genymotion:

https://www.genymotion.com/#!/download
(https://www.genymotion.com/#!/download) En ella, nos descargamos la
versión de nuestro Sistema Operativo. Recomendamos descargar la versión
que incluye Virtual Box, para evitar fallos por incompatibilidad con otra
versión de Virtual Box, que no sea la que utiliza la última versión de
Genymotion.
3. Instalamos el programa, según el sistema operativo que utilicemos, siguiendo
el Asistente de instalación de Genymotion.

4. Una vez instalado, creamos nuestro primer dispositivo virtual en

Genymotion. Lo hacemos pulsando en el botón "Add" y seleccionando del
listado de dispositivos que aparece:

5. Instalamos el Plugin de Genymotion para Android Studio. La ventaja es

simplemente, la de tener un acceso directo en la Toolbar de Android Studio,
desde el que abrir Genymotion.

Para ellos, accedemos a las Preferencias

de Android Studio. En el caso de MAC
OSX:
Y a continuación, en la sección de Plugin, buscamos Genymotion y lo instalamos.

Configurando Genymotion
Lo primero que debemos hacer, para hacer uso de la aplicación Genymotion, es iniciar
sesión con la cuenta que previamente hemos debido crear, registrándonos en:
https://www.genymotion.com/#!/auth/account-creation
(https://www.genymotion.com/#!/auth/account-creation).

En primer lugar, en Settings > en la pestaña Account > Pulsamos en Sign in > y por
último introducimos los datos de nuestra cuenta.
En la pestaña Virtual box, de la pantalla de Settings, podemos indicar la ruta en la que
se guardarán los dispositivos virtuales que creemos con Genymotion.
También debemos indicar en qué ruta tenemos instalada la SDK de Android. Lo
hacemos en la pestaña ADB:
Por último, podemos configurar la carpeta destino en la que deseamos guardar las
capturas de pantalla de los dispositivos virtuales, que podemos tomarlas por ejemplo
para completar la ficha de nuestra aplicación en Google Play. Además, en la pestaña
Misc, podemos limpiar la caché de Genymotion, que, en ciertas ocasiones, puede ser
útil.

Crear dispositivos virtuales.

Para crear un dispositivo virtual, debemos pulsar en la página principal de Genymotion
el botón Add:
A continuación, debemos seleccionar qué dispositivo queremos instalar, teniendo en
cuenta el tamaño (resolución de pantalla) del dispositivo y la versión (API) de Android.
Una vez seleccionado el modelo sobre el que queremos crear el dispositivo virtual,
pulsamos en el botón Next y nos encontramos con la pantalla siguiente, en la que
podemos escribir un nombre para describir el dispositivo:

Volvemos a pulsar en el botón Next y a continuación, Genymotion, descargará de

Internet la imagen del dispositivo:
Configurar Android Studio
Android Studio proporciona asistentes y plantillas que verifican los requisitos de tu sistema,
como el Java Development Kit (JDK) y la memoria RAM disponible, y configuran los ajustes
predeterminados, como una emulación optimizada predeterminada del Android Virtual
Device (AVD) e imágenes del sistema actualizadas. En este documento, se describen ajustes
de configuración adicionales que puedes usar para personalizar tu uso de Android Studio.
Android Studio proporciona acceso a dos archivos de configuración a través del menú Help:
• studio. vmoptions: Permite personalizar opciones para Java Virtual Machine (JVM)
de Studio, como el tamaño de montón y caché. Ten en cuenta que, según tu versión de
Android Studio, este archivo puede llevar el nombre studio64.vmoptions en los equipos con
Linux.
• idea. properties: Permite personalizar las funciones de Android Studio, como la ruta
de acceso de la carpeta de complementos o el tamaño máximo de archivo admitido.
Para acceder a documentación específica acerca de la configuración y el uso del emulador y
el dispositivo, consulta Administración de dispositivos virtuales, Uso de dispositivos de
hardware, y Controladores USB de OEM.
Buscar tus archivos de configuración
Los archivos de configuración se almacenan en la carpeta de configuración para Android
Studio. El nombre de la carpeta depende de tu versión de Studio. Por ejemplo, el nombre de
la carpeta para Android Studio 2.2 es AndroidStudio2.2. La ubicación de esta carpeta
depende de tu sistema operativo:
• Windows: %USERPROFILE%\. <CONFIGURATION_FOLDER>/
• Mac: ~/Library/Preferences/<CONFIGURATION_FOLDER>/
• Linux: ~/. <CONFIGURATION_FOLDER>/
También puedes usar las siguientes variables de entorno para señalar archivos de anulación
específicos en otro lugar:
• STUDIO_VM_OPTIONS: permite establecer el nombre y la ubicación del archivo.
vmoptions.
• STUDIO_PROPERTIES: permite establecer el nombre y la ubicación del archivo.
properties.
• STUDIO_JDK: permite establecer el JDK con el cual se ejecutará Studio.
Personalizar las opciones del VM
El archivo studio. vmoptions te permite personalizar las opciones para la JVM de Android
Studio. Para mejorar el rendimiento de Studio, la opción más común es ajustar el tamaño
máximo de montón; sin embargo, también puedes usar el archivo studio. vmoptions a fin de
anular otras configuraciones predeterminadas, como los cambios de tamaño inicial de
montón, tamaño de caché y recolección de elementos no usados de Java.
Para crear un archivo studio. vmoptions nuevo o abrir uno existente, realiza los siguientes
pasos:
1. Haz click en Help > Edit Custom VM Options. Si nunca editaste las opciones de VM
de Android Studio, el IDE te solicitará crear un archivo studio. vmoptions nuevo. Haz clic
en Yes para crear el archivo.
2. El archivo studio. vmoptions se abrirá en la ventana del editor de Android Studio.
Edita el archivo para agregar tus propias opciones personalizadas de VM. Para hallar una
lista completa de opciones de JVM personalizables, consulta la página de opciones de VM
de Java HotSpot de Oracle.
El archivo studio. vmoptions que crees se agregará al archivo studio. vmoptions
predeterminado, ubicado en el directorio bin/ de tu carpeta de instalación de Android Studio.
Ten en cuenta que nunca debes editar directamente el archivo studio. vmoptions situado
dentro de la carpeta de programa de Android Studio. Cuando puedas acceder al archivo para
ver las opciones predeterminadas del VM de Studio, editar solo tu archivo studio. vmoptions
te garantizará que no anules configuraciones predeterminadas importantes para Android
Studio. Por lo tanto, en tu archivo studio. vmoptions, anula solo los atributos que te importen
y permite que Android Studio continúe usando los valores predeterminados para cualquier
atributo que no hayas cambiado.
Tamaño máximo de montón
De forma predeterminada, Android Studio tiene un tamaño máximo de montón de 1280 MB.
Si trabajas en un proyecto grande o tu sistema tiene mucha RAM, puedes mejorar el
rendimiento aumentando el tamaño máximo de montón en las opciones del VM para Android
Studio. Si tu sistema tiene restricciones de memoria, tal vez desees reducir el tamaño máximo
de montón.
Para cambiar el tamaño máximo de montón, sigue estos pasos:
1. Haz click en Help > Edit Custom VM Options para abrir tu archivo studio. vmoptions.
2. Agrega una línea al archivo studio. vmoptions para fijar el tamaño máximo de montón
usando la sintaxis -XmxheapSize. El tamaño que elijas se debe basar en el tamaño de tu
proyecto y la memoria RAM disponible en tu equipo. Como referencia, si tienes más de 4
GB de memoria RAM y un proyecto de tamaño medio, debes fijar el tamaño máximo del
montón en 2 GB o más. Con la siguiente línea, se fija el tamaño máximo de montón en 2 GB:
-Xmx2g
3. Guarda tus cambios en el archivo studio. vmoptions y reinicia Android Studio para
que se apliquen esos cambios.
4. Para confirmar tu nuevo tamaño máximo de montón, abre la línea de comandos y
escribe el siguiente:
jps -lvm
Verás una lista de JVM instrumentadas que se ejecutan en tu equipo; se incluirán el nombre
completo del paquete de cada uno y los argumentos pasados. Ubica el elemento que
corresponde a tu instancia de Android Studio. Debe terminar con -Didea.paths.
selector=AndroidStudio[Versión]. Verás dos argumentos que comienzan con -Xmx para este
JVM: uno con el valor predeterminado de 1280 MB y otro con tu valor nuevo, como se
muestra en la figura 1.

Figura 1: Salida terminal muestra los argumentos actuales para el JVM de Android Studio.
1. El argumento -Xmx muestra el tamaño máximo de montón predeterminado; en este
caso, 1280 m.
2. El argumento -Didea.paths. selector muestra la versión de Android Studio que
actualmente se ejecuta.
3. El argumento -Xmx muestra el nuevo tamaño máximo del montón personalizado. Ten
en cuenta que a esto le sigue la ubicación del archivo personalizado studio. vmoptions que
creaste anteriormente.
Exportar e importar configuraciones de IDE
Puedes exportar un archivo de configuración JAR (Settings.jar) que contenga todas tus
configuraciones de IDE o un subconjunto de estas que prefieras para un proyecto. Luego,
puedes importar el archivo JAR a tus demás proyectos y hacer que esté disponible para que
tus colegas lo importen a sus proyectos.
Para obtener más información, consulta Exportar e importar configuraciones en IntelliJ
IDEA.
Personalizar tus propiedades de IDE
El archivo idea. properties te permite personalizar las propiedades de IDE para Android
Studio, como la ruta de acceso a los complementos instalados por el usuario y el tamaño
máximo de archivo admitido por el IDE. El archivo idea. properties se fusiona con las
propiedades predeterminadas para el IDE, de modo que puedas especificar solo las
propiedades anuladas.
Para crear un archivo nuevo idea. properties o abrir uno existente, realiza los siguientes pasos:
1. Haz click en Help > Edit Custom Properties. Si nunca editaste las propiedades del
IDE antes, Android Studio te solicitará crear un archivo idea. properties nuevo. Haz clic en
Yes para crear el archivo.
2. El archivo idea. properties se abrirá en la ventana del editor de Android Studio. Edita
el archivo para agregar tus propias propiedades personalizadas de IDE.
En el siguiente archivo idea. properties se incluyen las propiedades de IDE comúnmente
personalizadas. Para obtener una lista completa de propiedades, lee información sobre el
archivo idea. properties para IntelliJ IDEA.
#---------------------------------------------------------------------
# Uncomment this option if you want to customize path to user installed plugins folder. Make
sure
# you're using forward slashes.
#---------------------------------------------------------------------
# idea. plugins. Path=${idea.config. path}/plugins
#---------------------------------------------------------------------
# Maximum file size (kilobytes) IDE should provide code assistance for.
# The larger file is the slower its editor works and higher overall system memory
requirements are
# if code assistance is enabled. Remove this property or set to very large number if you need
# code assistance for any files available regardless their size.
#---------------------------------------------------------------------
idea. Ax. intelligence. file size=2500
#---------------------------------------------------------------------
# This option controls console cyclic buffer: keeps the console output size not higher than
the
# specified buffer size (Kb). Older lines are deleted. In order to disable cycle buffer use
# idea. cycle. buffer. Size=disabled
#---------------------------------------------------------------------
idea. cycle. buffer. Size=1024
#---------------------------------------------------------------------
# Configure if a special launcher should be used when running processes from within IDE.
# Using Launcher enables "soft exit" and "thread dump" features
#---------------------------------------------------------------------
idea.no. launcher=false
#---------------------------------------------------------------------
# To avoid too long class path
#---------------------------------------------------------------------
idea. dynamic. class path=false
#---------------------------------------------------------------------
# There are two possible values of idea. popup. Weight property: "heavy" and "medium".
# If you have WM configured as "Focus follows mouse with Auto Raise" then you have to
# set this property to "medium". It prevents problems with popup menus on some
# configurations.
#---------------------------------------------------------------------
idea. popup. Weight=heavy
#---------------------------------------------------------------------
# Use default anti-aliasing in system, i.e. override value of
# "Settings|Editor|Appearance|Use anti-aliased font" option. May be useful when using
Windows
# Remote Desktop Connection for instance.
#---------------------------------------------------------------------
idea.use.default.antialiasing.in. editor=false
#---------------------------------------------------------------------
# Disabling this property may lead to visual glitches like blinking and fail to repaint
# on certain display adapter cards.
#---------------------------------------------------------------------
sun. java2d.noddraw=true
#---------------------------------------------------------------------
# Removing this property may lead to editor performance degradation under Windows.
#---------------------------------------------------------------------
sun.java2d.d3d=false
#---------------------------------------------------------------------
# Workaround for slow scrolling in JDK6
#---------------------------------------------------------------------
swing. bufferPerWindow=false
#---------------------------------------------------------------------
# Removing this property may lead to editor performance degradation under X Window.
#---------------------------------------------------------------------
sun. java2d.pmoffscreen=false
#---------------------------------------------------------------------
# Workaround to avoid long hangs while accessing clipboard under Mac OS X.
#---------------------------------------------------------------------
# ide.mac. useNativeClipboard=True
#---------------------------------------------------------------------
# Maximum size (kilobytes) IDEA will load for showing past file contents -
# in Show Diff or when calculating Digest Diff
#---------------------------------------------------------------------
# idea.max.vcs. loaded. size. kb=20480

Configurar el IDE para equipos de memoria insuficiente

Si ejecutas Android Studio en un equipo con menos especificaciones de las recomendadas
(consulta Requisitos del sistema), puedes personalizar el IDE para mejorar el rendimiento de
tu equipo de la siguiente manera:
• Reducir el tamaño máximo del montón disponible en Android Studio: reduce a 512
MB el tamaño máximo de montón para Android Studio. Para obtener más información sobre
el cambio del tamaño máximo de montón, consulta Tamaño máximo de montón.
• Actualizar Gradle y el complemento de Android para Gradle: realiza actualizaciones
a las últimas versiones de Gradle y del complemento de Android para Gradle, a fin de
asegurarte de aprovechar las últimas mejoras de rendimiento. Para obtener más información
sobre la actualización de Gradle y el complemento de Android para Gradle, consulta Notas
de la versión del complemento de Android para Gradle.
• Habilitar el modo de ahorro de energía: la habilitación del modo de ahorro de energía
desactiva varias operaciones de segundo plano que consumen mucha memoria y batería,
incluidos el resalte de errores y las inspecciones en el momento, la compleción de código
emergente automático y la compilación incremental automática en segundo plano. Para
activar el modo de ahorro de energía, haz clic en File > Power Save Mode.
• Inhabilitar comprobaciones de lint innecesarias: para cambiar las comprobaciones de
lint que Android Studio ejecuta en tu código, sigue los pasos siguientes.
1. Haz clic en File > Settings (en Mac, Android Studio > Preferences) para abrir el
diálogo de configuración.
2. En el subpanel izquierdo, expande la sección Editor y haz clic en Inspections.
3. Haz clic en las casillas de verificación para seleccionar o deseleccionar verificaciones
de lint según corresponda para tu proyecto.
4. Haz clic en Apply o OK para guardar los cambios.
• Realizar depuraciones en un dispositivo físico: la depuración requiere más memoria
en un emulador que en un dispositivo físico. Por ello, puedes mejorar el rendimiento general
para Android Studio realizando depuraciones en un dispositivo físico.
• Incluir solo los servicios necesarios de Google Play como dependencias: incluir
servicios de Google Play como dependencias en tu proyecto aumenta el volumen de memoria
necesario. Incluye únicamente las dependencias necesarias para mejorar el uso y el
rendimiento de la memoria. Para obtener más información, consulta Agregar servicios de
Google Play a tu proyecto.
• Activar el modo sin conexión para Gradle: si tu ancho de banda es limitado, activa el
modo sin conexión para evitar que Gradle intente descargar dependencias faltantes durante
tu compilación. Si faltan dependencias, Gradle mostrará una falla en lugar de intentar
descargarlas cuando esté activado el modo sin conexión. Para activar el modo sin conexión,
sigue estos pasos:
1. Haz clic en File > Settings (en Mac, Android Studio > Preferences) para abrir el
diálogo de configuración.
2. En el subpanel izquierdo, expande Build, Execution, Deployment y luego haz clic en
Gradle.
3. En la configuración global de Gradle, marca la casilla de verificación Offline work.
4. Haz clic en Apply u OK para que se apliquen los cambios.
• Reducir el tamaño máximo de montón disponible para la compilación de archivos
DEX: fija javaMaxHeapSize para compilación de archivos DEX en 200m. Para obtener más
información, consulta Mejorar los tiempos de compilación configurando recursos DEX.
• No habilitar la compilación en paralelo: Android Studio puede compilar módulos
independientes en paralelo, pero si tu sistema tiene bajos recursos de memoria no debes
activar esta función. Para comprobar esta configuración, sigue estos pasos:
1. Haz clic en File > Settings (en Mac, Android Studio > Preferences) para abrir el
diálogo de configuración.
2. En el subpanel izquierdo, expande Build, Execution, Deployment y luego haz clic en
Compiler.
3. Asegúrate de que no esté marcada la opción Compile independent modules in parallel.
4. Si has realizado un cambio, haz clic en Apply o en OK para que los cambios tengan
efecto.
Configurar tu proyecto para Instant Run
Instant Run es un comportamiento para los comandos Run y Debut que reduce
significativamente el tiempo entre actualizaciones de tu app. Si bien la primera compilación
puede demorar más tiempo en completarse, Instant Run aplica actualizaciones posteriores en
tu app sin compilar un APK nuevo, de modo que los cambios se visualicen mucho más
rápido.
Android Studio habilita Instant Run de forma predeterminada para proyectos generados con
un complemento de Android para Gradle 2.0.0 y versiones posteriores. Puedes mejorar el
rendimiento de la compilación con Instant Run modificando algunas configuraciones para tu
proyecto. Si deseas obtener más información sobre la configuración de tu proyecto para
Instant Run, lee Configurar y optimizar tu proyecto para Instant Run.
Establecer la versión de JDK
Una copia del último OpenJDK se incluye en un paquete con Android Studio 2.2 y versiones
posteriores, y esta es la versión de JDK que te recomendamos usar para tus proyectos de
Android. Para usar el JDK incluido, sigue estos pasos:
1. Abre tu proyecto en Android Studio y selecciona File > Project Estructure en la barra
de menú.
2. En la página SDK Location y en JDK Location, marca la casilla de verificación Use
embedded JDK.
3. Haz clic en OK.
De forma predeterminada, la versión en lenguaje Java que se usa para compilar tu proyecto
se basa en la compileSdkVersion de tu proyecto (porque las versiones diferentes de Android
admiten diferentes versiones de Java). Si es necesario, puedes anular esta versión
predeterminada de Java agregando el siguiente bloque CompileOptions {} a tu archivo build.
Gradle:
android {
 CompileOptions {
source Compatibility JavaVersion.VERSION_1_6
targetCompatibility JavaVersion.VERSION_1_6
}
}
Para obtener más información sobre el punto en el que se define la compileSdkVersion, lee
la documentación sobre el archivo de compilación de nivel de módulo.
Establecer configuraciones de proxy
Los proxys sirven como puntos de conexión intermedios entre los clientes HTTP y los
servidores web, y proporcionan seguridad y privacidad para las conexiones de Internet.
Para admitir la ejecución de Android Studio con un firewall, establece las configuraciones
de proxy para el IDE de Android Studio. Usa la página de ajustes de proxy HTTP del IDE
de Android Studio para configurar estos ajustes.
Cuando se ejecuta el complemento de Android para Gradle desde la línea de comandos o en
equipos sin Android Studio, como los servidores de integración continua, establece las
configuraciones de proxy en el archivo de compilación de Gradle.
Nota: Después de la instalación inicial del paquete de Android Studio, puedes ejecutarlo con
acceso a Internet o sin conexión. No obstante, Android Studio requiere una conexión a
Internet para la sincronización del asistente de configuración, el acceso a bibliotecas de
terceros, el acceso a repositorios remotos, la inicialización y sincronización de Gradle, y
actualizaciones de versión de Android Studio.
Configurar el proxy de Android Studio
Android Studio admite ajustes de configuración de proxy HTTP para que puedas ejecutar
Android Studio detrás de un firewall o una red segura. Para configurar el proxy HTTP en
Android Studio:
1. En la barra de menú, haz clic en File > Settings (en Mac, en Android Studio >
Preferences).
2. En el subpanel izquierdo, haz click en Appearance & Behavior > System Settings >
HTTP Proxy. Aparecerá la página del Proxy HTTP.
3. Selecciona Auto-detect proxy Settings para usar una URL de configuración
automática de proxy o Manual proxy Configuration para ingresar cada una de las
configuraciones tú mismo. Para acceder a una explicación detallada de estos ajustes, consulta
Proxy HTTP.
4. Haz clic en Apply u OK para que se apliquen los cambios.
Complemento de Android para las configuraciones de proxy HTTP de Gradle
Cuando se ejecuta el complemento de Android desde la línea de comandos o en equipos sin
Android Studio, establece la configuración de proxy del complemento de Android para
Gradle en el archivo de compilación de Gradle.
Para configuraciones de proxy HTTP específicas de aplicaciones, establece la configuración
de proxy en el archivo build. Gradle según sea necesario para cada módulo de la aplicación.
apply plugin: 'com. android. Application'

android {
...

defaultConfig {
...

systemProp.http.proxyHost=proxy.company.com
systemProp.http. proxy Port=443
systemProp.http. proxy User=userid
systemProp.http. proxy Password=password
systemProp.http. auth. ntlm. domain=domain
}
...

}
Para configuraciones de proxy HTTP en un proyecto, establece la configuración de proxy en
el archivo Gradle/Gradle. Properties.
# Project-wide Gradle settings.

systemProp.http.proxyHost=proxy.company.com
systemProp.http. proxy Port=443
systemProp.http. proxy User=username
systemProp.http. proxy Password=password
systemProp.http. auth. ntlm. domain=domain
systemProp.https.proxyHost=proxy.company.com
systemProp.http. proxy Port=443
systemProp.http. proxy User=username
systemProp.http. proxyPassword=password
systemProp.http. auth. ntlm. Domain=domain

Android es un Sistema operativo de código abierto para dispositivos móviles, se programa

principalmente en java, y su núcleo está basado en Linux.
En la actualidad los sistemas operativos abstraen al programador del hardware.
Un ejemplo clásico es Symbiam. Pero este tipo de plataformas todavía requieren
que el programador escriba código C/C++ complicado, haciendo uso de
bibliotecas (libraries) propietarias. Especiales complicaciones pueden surgir
cuando se trabaja con hardware específico, como GPS, TrackBall o
touchscreens, etc. Java ME abstrae completamente al programador del
hardware, pero su limitación de máquina virtual le recorta mucho la libertad
para acceder al hardware del dispositivo.
Open source
Android - tanto el sistema operativo, como la plataforma de desarrollo - están
liberados bajo la licencia de Apache. Esta licencia permite a los fabricantes
añadir sus propias extensiones propietarias, sin tener que ponerlas en manos de
la comunidad de software libre.
Al ser de open source, Android hace posible:
• Una comunidad de desarrollo, gracias a sus completas APIs y documentación
ofrecida.
• Desarrollo desde cualquier plataforma (Linux, Mac, Windows, etc.).
• Un sistema operativo para cualquier tipo de dispositivo móvil, al no estar
diseñado para un sólo tipo de móvil.
¿Quién desarrolla Android?
La Open Handset Alliance. Consorcio de varias compañías que tratan de definir
y establecer una serie de estándares abiertos para dispositivos móviles. El
consorcio cuenta con decenas de miembros que se pueden clasificar en varios
tipos de empresas:
• Operadores de telefonía móvil
• Fabricantes de dispositivos
• Fabricantes de procesadores y microelectrónica
• Compañías de software
• Compañías de comercialización

Dispositivos

Los dispositivos con Android son numerosos. Aunque los hay de tipos muy diferentes, los
principales son los tablet y los teléfonos móviles. La configuración típica es la de
pantalla táctil y algunos botones para el menú, salir, home, apagar, volumen. Mucho
dispositivos también cuentan con un teclado físico, y algunos incluso cuentan con varias
pantalla.

Teléfono de desarrollar de Android

Motorola Charm
Qualcomm es el fabricante del procesador Snapdragon, procesador basado en
ARM que se está utilizando en los últimos dispositivos móviles del mercado.
Realmente es una plataforma que en algunos de sus modelos incluye dos CPU
de 1.5 GHz, HSPA+, GPS, Bluetooth, grabación y reproducción de video full
definition, Wi-Fi y tecnologías de televisión móvil. Lo están utilizando no sólo
los fabricantes de teléfonos, sino también los de tablets y notebooks.

Desarrollo de aplicaciones

Aunque el desarrollo de librerías de bajo nivel es posible con el Android Native Development
Toolkit, vamos a centrarnos en el desarrollo de aplicaciones con el Android Software
Development Toolkit.

Android SDK

El SKD de Android incluye numerosas y completas APIs para facilitar el desarrollo.

Algunas de las características más relevantes son:
• Licencias, distribución y desarrollo gratuitos, tampoco hay procesos de
aprobación del software.
• Acceso al hardware de Wifi, GPS, Bluetooth y telefonía, permitiendo realizar y
recibir llamadas y SMS.
• Control completo de multimedia, incluyendo la cámara y el micrófono.
• APIs para los sensores: acelerómetros y brújula.
• Mensajes entre procesos (IPC).
• Almacenes de datos compartidos, SQLite, acceso a SD Card.
• Aplicaciones y procesos en segundo plano.
• Widgets para la pantalla de inicio (escritorio).
• Integración de los resultados de búsqueda de la aplicación con los del sistema.
• Uso de mapas y sus controles desde las aplicaciones.
• Aceleración gráfica por hardware, incluyendo OpenGL ES 2.0 para los 3D.
 Tipos de aplicaciones

Hay tres tipos de aplicaciones para Android: las de primer plano (foreground), las de segundo
plano (background) y los widgets (o App Widget).

Consideraciones para el desarrollo

El desarrollo para dispositivos móviles y embebidos requiere que el

programador tenga especial cuidado en determinados aspectos. El sistema
operativo no puede encargarse de controlar todo porque limitaría demasiado al
programador, así que determinados aspectos como ahorrar CPU y memoria son
responsabilidad del programador en la mayoría de los casos. Las limitaciones
de hardware que el dispositivo impone suelen ser:
• Pequeña capacidad de procesamiento
• Memoria RAM limitada
• Memoria permanente de poca capacidad
• Pantallas Pequeña de poca resolución
• Transferencias de datos costosa (en términos de energía y económicos) y
lenta
• Inestabilidad de las conexiones de datos
• Batería muy limitada
Necesidad de terminar la aplicación en cualquier momento.

Emulador
Android SDK viene con un emulador en el que podemos probar la mayoría de nuestras
aplicaciones. Desde Eclipse podemos ejecutar nuestras aplicaciones directamente en un
emulador arrancado, que corre sobre un puerto. También podemos tener varios emuladores
arrancados para que se comuniquen entre ellos si la aplicación lo requiere. Dentro del
emulador contamos con una distribución de Android instalada con sus aplicaciones nativas
y la mayoría de las funcionalidades.
Podemos simular GPS, llamadas entrantes, salientes, SMS, entradas por la
pantalla y el teclado, reproducción de audio y vídeo, y comunicaciones por red.
Todos los tipos de aplicaciones están soportadas: widgets, servicios y
actividades. Se pueden instalar y desinstalar como si de un móvil real se tratara.
Todavía no se pueden simular conexiones por USB, captura por la cámara, auriculares o
manos libres conectados al móvil, conexión o desconexión de la corriente eléctrica ni el
estado de la batería, bluetooth, tampoco la inserción y extracción de la tarjeta de memoria
SD, sensores, ni tampoco el multi Touch.

Emulador de Android
El emulador incluye una consola a la que se puede conectar por telnet:

telnet localhost <Puerto>

El puerto suele ser el 5554, como en el ejemplo de la imagen. Se indica en la

barra de la ventana del emulador. Este puerto también se utiliza como número
de teléfono para simular llamadas y SMS.
El emulador de Android necesita información de configuración del dispositivo
virtual, denominado AVD, Android Virtual Device. Debemos crear un
dispositivo AVD para poder arrancar el emulador con determinada
configuración. En esta configuración debemos especificar el nivel de API que
tiene el dispositivo (por ejemplo, para el caso de Android 2.2 el nivel de API es
el 8), el tipo de pantalla y el resto del hardware: tarjeta SD, presencia de teclado
físico, etc. Esta configuración se puede crear con el AVD Manager del plugin
de Eclipse.
Desarrollo de una app para dispositivos móviles con configuración del archivo de permisos

Desarrollo de una app para dispositivos móviles con acceso a datos