Android Studio IDE 1.0. Características.

Por fin nos llega la versión estable del que a partir de ahora será el IDE oficial para Android: Android Studio 1.0.

Un editor de código inteligente.

Android Studio cuenta con un editor de código inteligente capaz de realizar tareas de completado, refactorización y un análisis avanzado de nuestro código. El editor nos ayudará a ser más productivos como desarrolladores de aplicaciones Android.

Imagen 1. Editor de código en Android Studio 1.0.

Procesos y hebras

Cuando una aplicación se ejecuta por primera vez, a través de alguno de sus componentes, el sistema creará para ella un proceso y un flujo de ejecución principal. Por defecto, todos los componentes de una aplicación se ejecutan en el mismo proceso y hebra principal. Sin embargo, si ello fuera necesario, podremos ejecutar los componentes de nuestra aplicación en procesos distintos y dentro de estos, crear las hebras secundarias que consideremos oportunas.

Procesos.

Por defecto, todos los componentes de una aplicación se ejecutan dentro del mismo proceso. Este comportamiento será suficiente para la mayoría de las aplicaciones. No obstante, si necesitamos cambiar este funcionamiento, podremos hacerlo desde el archivo manifest.

Todos los elementos asociados a componentes del archivo manifest: <activity>, <service>, <receiver> y <provider>, soportan el atributo android:process. A través de este atributo podremos especificar el proceso en el que queremos que sea ejecutado el componente. Incluso podríamos utilizar el mismo proceso para componentes de aplicaciones diferentes. Para este último caso, las aplicaciones deberán ejecutarse con el mismo usuario y estar firmadas con el mismo certificado.

El elemento <application> también cuenta con el atributo android:process que podríamos usar para definir el proceso por defecto para todos los componentes de una aplicación.

Hay momentos en los que el sistema se verá obligado a detener ciertos procesos para obtener los recursos requeridos por procesos con mayor prioridad. Cuando un proceso es eliminado por el sistema, todos sus componentes de aplicación serán destruidos.

A la hora de eliminar procesos, el sistema sopesa la importancia de éstos de cara al usuario. Por ejemplo, procesos con actividades que llevan un tiempo considerable siendo no visibles, tendrán un menor peso que aquellos procesos cuyas actividades sean visibles. La decisión de cuándo eliminar un proceso viene determinada por el estado de sus componentes.

Mensajes emergentes

Utilizaremos un mensaje emergente Toast para informar brevemente al usuario sobre el estado de una determinada operación. Por ejemplo, cuando creamos un nuevo correo electrónico y lo abandonamos sin haberlo enviado, el sistema nos mostrará un mensaje emergente en el que se nos comunica que será guardado como borrador y que podremos recuperarlo con posterioridad. Los mensajes de este tipo se muestran durante un breve espacio de tiempo.

Si por alguna razón necesitamos que el usuario sea capaz de realizar algún tipo de acción adicional como respuesta al mensaje, utilizaremos una notificación Notify en su lugar.

Listas desplegables

Una lista desplegable nos ofrece una manera rápida de seleccionar una opción dentro de un conjunto de opciones. Una lista desplegable muestra por defecto la opción actualmente seleccionada. Cada vez que pulsamos sobre una lista desplegable, se nos mostrará un menú con todas las opciones disponibles desde el que podremos realizar una nueva selección.

Para añadir una lista desplegable a nuestra plantilla XML, utilizaremos un elemento Spinner. Por ejemplo:

<Spinner
    android:id="@+id/planets_spinner"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content" />

Para añadir las opciones a la lista desplegable utilizaremos un un adaptador SpinnerAdapter desde una actividad o fragmento.

Botones de estado

Un botón de estado puede tomar dos valores posibles: activo o inactivo. Podemos añadir botón de estado estándar a nuestra plantilla con el elemento ToggleButton. A partir de la versión 4.0 de Android contamos con un nuevo tipo de botón de estado Switch con control deslizante.

Botón de estado estándar.

Botón de estado con control deslizante (Android 4.0+).

ToggleButton y Switch son subclases de la clase CompoundButton por lo que funcionan de manera similar.

Botones radiales

Los botones radiales permiten al usuario seleccionar una opción de un conjunto de opciones mutuamente excluyentes.

Utilizaremos el elemento RadioButton para añadir un botón radial a nuestra plantilla. Además, tendremos que definir los botones dentro de un elemento RadioGroup si queremos que la selección sea excluyente.

Casillas de verificación

Las casillas de verificación permiten al usuario hacer una selección múltiple dentro de un conjunto de opciones. Lo normal es que las opciones se muestren distribuidas de manera vertical:

Para crear una casilla de verificación utilizaremos un elemento CheckBox en nuestra plantilla. Debido a que el usuario puede seleccionar varias opciones, cada casilla de verificación será tratada de manera independiente y cada una recibirá sus propios eventos.

Campos de texto

Los campos de texto permiten al usuario introducir texto en una o varias líneas. Cada vez que pulsamos sobre un campo de texto nos aparecerá un teclado virtual que nos permitirá escribir a partir de un cursor de escritura. También nos ofrece la posibilidad de seleccionar parte del texto (para copiar, pegar o cortar) y funciones de autocompletado.

Para añadir un campo de texto a nuestra plantilla usaremos un elemento EditText.

Botones

Un botón es una zona rectangular que puede contener un texto, un icono o un texto más un icono y que cuando es pulsado realiza una acción.

Para crear los botones de la imagen anterior en nuestra plantilla, procederemos de la siguiente manera:

• Si queremos mostrar texto, utilizaremos la clase Button:
  

  <Button
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="@string/button_text"
      ... />
  

• Si queremos mostrar un icono, utilizaremos la clase ImageButton:
  

  <ImageButton
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:src="@drawable/button_icon"
      ... />
  

• Si queremos mostrar un texto y un icono, utilizaremos la clase Button y el atributo android:drawableLeft:
  

  <Button
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="@string/button_text"
      android:drawableLeft="@drawable/button_icon"
      ... />
  

Controles de entrada de datos

Los controles para la entrada de datos son componentes de la interfaz de usuario con los que se puede interactuar. Android nos proporciona un juego de controles de este tipo que podremos utilizar de manera fácil en nuestros diseños: botones, campos de texto, barras de ajuste, casillas de verificación, botones de zoom, botones de estado y muchos más.

Vistas de tipo cuadrícula

Una vista de tipo GridView es una vista de grupo que muestra sus elementos distribuidos en una cuadrícula permitiendo desplazamiento de pantalla. Los elementos se pueden añadir automáticamente a la plantilla usando un adaptador de tipo ListAdapter.

Vistas de tipo lista

Una vista de tipo ListView es una vista de grupo que muestra un listado de elementos permitiendo desplazamiento de pantalla. Los elementos se añaden y se actualizan de manera automática a la lista a través de un adaptador Adapter. El adaptador se encargará de construir la vista para cada elemento y añadirla a la lista. Para ello, el adaptador utilizará una fuente de datos (un array o el cursor resultado de una consulta, por ejemplo) y de una plantilla auxiliar.

Plantillas con distribución relativa

Una plantilla RelativeLayout es una vista de grupo que muestra a sus vistas hija con posicionamiento relativo. El posicionamiento de una vista se especifica en función de otra vista (a la izquierda de o debajo de otra vista, por ejemplo) o en función del área descrita por la plantilla (alineada a la izquierda o al centro, por ejemplo).

Una plantilla con posicionamiento relativo nos proporciona una estructura plana, es decir, no existen vistas de grupo anidadas por lo que hay una mejora notable en el rendimiento. Estas plantillas son una buena alternativa al uso de vistas LinearLayout anidadas.

Plantillas con distribución lineal

Una plantilla LinearLayout es una vista de grupo donde todas sus vistas hija se alinean en una sola dirección: horizontal o vertical. Utilizaremos el atributo android:orientation para especificar la orientación de su contenido.

En este tipo de plantillas, las vistas hija son apiladas unas tras otras. Es decir,  si la orientación es vertical, habrá varias filas, una por cada vista hija, apiladas en una sola columna, y si la orientación es horizontal, tendremos varias columnas, una por cada vista hija, apiladas en una sola fila. Una plantilla LinearLayout respetará los márgenes (android:layout_marginLeft, android:layout_marginRight, etc) y las alineaciones (android:layout_gravity) de sus vistas hija con respecto a su vista padre.

Plantillas

Una plantilla nos permite definir el diseño de la interfaz de usuario de una actividad o de un widget de aplicación. La declaración de una plantilla se puede hacer de dos formas:

• Desde un archivo XML. Android nos proporciona de un sencillo espacio de nombres XML basado en clases del entorno de trabajo.
• Desde el código en tiempo de ejecución. Podríamos crear las vistas necesarias, definir sus dependencias y especificar sus propiedades desde el código si fuera necesario.

Interfaz de usuario, conceptos básicos

La interfaz de usuario de una aplicación es la parte que el usuario puede ver y con la que puede interactuar. Android nos proporciona una serie de contenedores y controles que podremos combinar para construir nuestra interfaz de usuario. Android también cuenta con un juego de componentes comunes a toda interfaz y que podremos utilizar en nuestros diseños: mensajes emergentes, cuadros de diálogo, menús, etc.

Todos los elementos que forman la interfaz de usuario de una aplicación están formados por objetos de tipo View (vista) y ViewGroup (vista de grupo). Un objeto de tipo View es un objeto que se muestra en pantalla y con el que el usuario puede interactuar. Un objeto de tipo ViewGroup es un objeto sin representación que puede contener otros objetos de tipo View o ViewGroup y que nos servirán para organizar nuestras plantillas.

Android nos proporciona una amplia variedad de vistas: botones, campos de texto, vistas de grupo con distribución lineal o relativa, etc.

Localización

Android se utiliza en muchos países y/o regiones al rededor de todo el mundo. Para poder llegar al mayor número de usuarios posible, nuestra aplicación tendrá que ser capaz de adaptarse a múltiples idiomas, formas de escritura, formatos de fecha, datos numéricos, archivos de sonido e imágenes relacionados con los idiomas y países de origen.

Los recursos son las cadenas de texto, plantillas, sonidos, imágenes y cualquier otro tipo de dato que nuestra aplicación necesite para su funcionamiento. Una aplicación puede incluir múltiples conjuntos de recursos adaptados a configuraciones diferentes de dispositivo. Cuando el usuario ejecuta la aplicación, Android seleccionará y cargará de manera automática los recursos que mejor se adapten a la configuración actual.

Gestionando cambios de configuración en tiempo de ejecución

La configuración de un dispositivo suele cambiar durante la ejecución de nuestra aplicación: orientación de la pantalla, disponibilidad del teclado, idioma, etc. Cuando uno de estos cambios sucede, el sistema reinicia la actividad que se está ejecutando justo en ese instante (se invocan sus métodos onDestroy y onCreate(), por ese orden). Durante este proceso, el sistema también actualiza los recursos con aquellos que mejor se adaptan a la nueva configuración.

Para gestionar de manera adecuada el reinicio de nuestra aplicación, será necesario implementar sus actividades para que éstas sean capaces de recuperar sus estados previos. Como norma general, utilizaremos el método onSaveInstanceState() para guardar los datos necesarios y utilizaremos los métodos onCreate() o onRestoreInstanceState() para recuperarlos posteriormente.

Accediendo a los recursos

Cada recurso en nuestra aplicación, se identifica a través de un ID de recurso. Se trata de un número entero único que se encuentra definido dentro de la clase especial R. Cada vez que la aplicación es compilada, la herramienta aapt generará automáticamente la clase R con todos los IDs asociados a los archivos contenidos en la carpeta res/ de nuestro proyecto. Por cada tipo de recurso se creará una subclase de la clase R (por ejemplo, R.drawable para recursos de tipo imagen), y por cada recurso se creará una constante de tipo entero (por ejemplo, R.drawable.icon, línea 9). Esta variable será la que utilizaremos para acceder al recurso.

La clase especial R:

public final class R {
    public static final class attr {
    }
    public static final class dimen {
        public static final int activity_horizontal_margin=0x7f040000;
        public static final int activity_vertical_margin=0x7f040001;
    }
    public static final class drawable {
        public static final int icon=0x7f020000;
    }
    public static final class id {
        public static final int action_settings=0x7f080002;
        public static final int listView=0x7f080001;
        public static final int textView=0x7f080000;
    }
    public static final class layout {
        public static final int activity_my=0x7f030000;
    }
...
}

Servicios, conceptos básicos

Un servicio es un componente de aplicación que ejecuta de manera indefinida operaciones en segundo plano y por tanto no necesita de una interfaz de usuario. Un servicio puede ser iniciado desde otro componente y seguir ejecutándose independientemente del estado del componente que lo inició. Además, un componente podrá conectarse a un servicio e interactuar con él a través de una interfaz (IPC - Inter Process Communication, Comunicación Entre Procesos). Por ejemplo, un servicio podría encargarse de gestionar las transacciones de red, de reproducir música, de realizar operaciones de entrada y salida (E/S), o de interactuar con un proveedor de contenido; todo ello desde un segundo plano.

Ciclo de vida de las actividades.

Cuando interactuamos con una aplicación, sus actividades cambian de estado continuamente. Por ejemplo, cuando una actividad se inicia por primera vez, ésta pasa a un primer plano para interactuar con el usuario. Durante este proceso, Android invoca una secuencia de métodos retrollamada asociados al ciclo de vida de la actividad.  Desde estos métodos, por ejemplo, podremos configurar la interfaz del usuario. Si el usuario realiza alguna acción pasando a iniciar otra actividad, o bien cambia de aplicación, será ésta última la que pase a un primer plano. La actividad inicial pasará a un segundo plano conservándose su estado.

Los métodos retrollamada relacionados con el ciclo de vida de una actividad nos serán útiles para especificar el comportamiento de ésta ante las idas y venidas del usuario. Por ejemplo, si estamos programando un reproductor para vídeo streaming, deberíamos detener la reproducción y cerrar la conexión de red cuando el usuario cambia de aplicación. Si el usuario decide volver al reproductor, volveremos a reestablecer la conexión de red y la reproducción justo donde se había quedado.

Cargadores

Los cargadores hicieron su primera aparición con la versión 3.0 de Android. El objetivo de un cargador es el de facilitar la carga y actualización de los datos usados en una actividad o fragmento. Entre sus características, podemos destacar:

• Pueden ser usados desde las actividades y fragmentos de nuestra aplicación.
• La carga de los datos puede realizarse de manera asíncrona.
• Detectan cambios en la fuente de datos y entregan los nuevos resultados.
• Si la configuración del dispositivo cambia, el cargador recuperará los datos de la última consulta sin tener que volver a repetirla, con el consiguiente ahorro de tráfico y procesamiento de datos.

Proveedores de contenido, conceptos básicos

Los proveedores de contenido son objetos encargados de gestionar el acceso a un conjunto de datos estructurados. Encapsulan los datos y nos proveen de mecanismos para definir su seguridad. Los proveedores de contenido definen una interfaz estándar que permite a un proceso compartir sus datos con otros procesos.

Cuando queremos acceder a los datos de un proveedor de contenido, utilizaremos el objeto ContentResolver asociado al contexto de nuestra aplicación para comunicarnos como cliente del proveedor. Es decir, utilizaremos el objeto ContentResolver para comunicarnos con un objeto ContentProvider. El objeto proveedor recibe las peticiones de datos desde uno o varios clientes, realiza las acciones solicitadas y devuelve los resultados.

Si los datos de nuestra aplicación no se van a compartir con otras aplicaciones, no tendremos que implementar nuestro propio proveedor. Sin embargo, necesitaremos desarrollar un proveedor para nuestra aplicación si queremos implementar mecanismos de búsqueda con predicción de texto. También necesitaremos de proveedores si queremos que se puedan copiar y pegar datos estructurados o archivos desde nuestra aplicación a otras aplicaciones.

Android incorpora una serie de proveedores de contenido para audio, vídeo, imágenes y contactos. Con algunas restricciones, estos proveedores serán accesibles desde cualquier aplicación.

Depuración

Android Studio nos permitirá depurar nuestras aplicaciones sobre dispositivos virtuales o físicos. Con Android Studio podremos:

• Seleccionar el dispositivo sobre el que queremos depurar nuestra aplicación.
• Visualizar el registro del sistema.
• Añadir puntos de ruptura en nuestro código.
• Examinar variables y evaluar expresiones en tiempo de ejecución.
• Ejecutar las herramientas para depuración desde el SDK de Android.
• Realizar capturas de pantalla y vídeo de nuestras aplicaciones.

Tareas y la pila de retroceso

Una aplicación suele estar formada por varias actividades. Cada actividad debe ser diseñada en torno a un tipo determinado de acción que el usuario puede realizar y que a su vez puede iniciar otras actividades. Por ejemplo, una aplicación de correo electrónico puede tener una actividad que muestre un listado con los mensajes entrantes y cuando el usuario selecciona uno, se inicia una nueva actividad para mostrar sus detalles.

Una actividad incluso puede iniciar actividades de otras aplicaciones. Por ejemplo, si queremos enviar un correo electrónico, podemos definir una intención para realizar una acción del tipo "send" y añadirle datos adicionales como la dirección del destinatario y el mensaje. Una actividad definida en alguna aplicación y que haya sido declarada para gestionar intenciones del tipo "send", será la encargada de enviar el correo (en el caso de que existan varias actividades en el sistema capaces de responder a la misma intención, el usuario podrá seleccionar qué actividad quiere usar). Una vez se ha enviado el correo, la actividad inicial se reanuda. Todo este proceso es transparente de cara al usuario que en todo momento cree estar en la misma aplicación. Para conseguir esto, Android gestiona ambas actividades dentro de la misma tarea.

Fragmentos

Una fragmento es un objeto de tipo Fragment que aporta su propia lógica y aspecto (IU) a una actividad. Una actividad puede contener más de un fragmento y éstos podrán ser reutilizados en varias actividades. Podemos pensar en los fragmentos como en los módulos de una actividad que cuentan con su propio ciclo de vida y que pueden ser añadidos y eliminados de una actividad mientras ésta se esté ejecutando.

Un fragmento siempre estará contenido en una actividad y su ciclo de vida dependerá del ciclo de vida de ésta. Por ejemplo, cuando una actividad entra en pausa, todos sus fragmentos también entrarán en pausa, y cuando una actividad es destruida, todos sus fragmentos también serán destruidos. Sin embargo, mientras una actividad se está ejecutando (es decir, se encuentra en estado reanudada), el estado de cada fragmento funcionará de manera independiente. Además, podremos añadir, eliminar o reemplazar fragmentos a nuestro antojo a través de un mecanismo basado en transacciones. Cada transacción, antes de ser confirmada, podrá ser registrada en una pila de retroceso para fragmentos que gestiona la propia actividad y que permitirá al usuario volver a estados previos con tan solo pulsar el botón de retroceso.

Como norma general, cuando añadimos un fragmento a una actividad, lo que estamos haciendo es insertando su plantilla dentro de la plantilla de la actividad. Podemos insertar un fragmento en una actividad de dos formas: de manera estática, añadiendo un elemento <fragment> a la plantilla de la actividad, o de manera dinámica, añadiendo el fragmento desde el código a una vista contenedora (ViewGroup) previamente instanciada. Sin embargo, no todos los fragmentos cuentan con una plantilla y su objetivo principal consistirá en aportar funcionalidad adicional a una actividad.

La vista de proyecto Android

La vista de proyecto Android nos muestra una versión simplificada de la estructura de nuestro proyecto, permitiéndonos acceder de manera rápida a los archivos más importantes, incluyendo los archivos relacionados con el sistema de builds Gradle. Esta vista se destaca porque:

• Agrupa los archivos relacionados con el sistema de builds Gradle.
• Muestra las carpetas más importantes para cada módulo del proyecto.
• Agrupa los archivos manifest por módulo.
• Agrupa los archivos de recursos teniendo en cuenta el idioma, la orientación de la pantalla, tipos de pantalla, etc.

Actividades

Una actividad es un componente de aplicación que proporciona una pantalla con la que el usuario puede interactuar con el fin de realizar alguna operación, como por ejemplo: hacer una llamada telefónica, hacer una fotografía, enviar un correo electrónico, o ver un mapa. Cada actividad está delimitada por su ventana en la que se muestra la interfaz de usuario. La ventana generalmente ocupa toda la pantalla, pero puede ser más pequeña y flotar sobre otras ventanas.

Una aplicación generalmente está formada por un conjunto de actividades relacionadas entre sí. Una, y solo una, de esas actividades la declararemos como la actividad principal de nuestra aplicación y eso hará que se inicie por defecto cuando el usuario ejecute la aplicación por primera vez.

Una actividad también puede ser iniciada a través de otra actividad con el fin de realizar diferentes acciones. Cuando iniciamos una actividad, ésta se añade a la pila de retroceso (back stack) y pasa a un primer plano, disponible para la interacción con el usuario. Cuando el usuario pulsa el botón de retroceso, la actividad actual se saca del tope de la pila y se destruye, reanudándose la actividad previa. Al sistema de funcionamiento de la pila de retroceso se le conoce por las siglas LIFO (Last In First Out - Último Entra, Primero Sale).

Los cambios de estado que sufre una actividad son comunicados por el sistema mediante la invocación de métodos retrollamada (callbacks) asociados a la propia actividad. Hay varios métodos retrollamada que una actividad puede recibir cuando ésta cambia de estado: cuando el sistema la crea, la detiene, la reanuda, o la destruye. Para cada uno de estos eventos, podremos realizar las operaciones que consideremos necesarias implementando su método correspondiente. Por ejemplo, cuando la actividad es detenida, deberíamos implementar lo necesario para liberar la memoria de objetos pesados, tales como conexiones de red o conexiones a bases de datos. Cuando la actividad se reanuda, recuperaremos los recursos necesarios y continuamos por donde lo habíamos dejado.

Intenciones y filtros de intenciones

Una intención (Intent) es un objeto que utilizaremos para iniciar un componente desde otro componente. Aunque las intenciones facilitan la comunicación entre componentes de varias maneras, hay tres casos de uso fundamentales:

• Para iniciar una actividad (Activity). Una actividad representa una pantalla de nuestra aplicación. Podemos iniciar una actividad pasando una intención como parámetro del método startActivity(). La intención describe qué actividad iniciar y transportará cualesquiera otros datos que fueran necesarios.
  
  
  Si además queremos recibir algún tipo de resultado desde la actividad cuando ésta finaliza, utilizaremos el método startActivityForResult(). La actividad que originó la solicitud, recibirá el resultado a través de una intención a la que podremos acceder desde su evento onActivityResult().
  
  
• Para iniciar un servicio (Service). Un servicio es un componente que realiza operaciones en segundo plano y que no cuenta con una interfaz de usuario. Puedes iniciar un servicio para realizar una operación (descargar un archivo, por ejemplo) pasando una intención como parámetro al método startService(). La intención describe el servicio a iniciar y transportará cualesquiera otros datos que fueran necesarios.
  
  
  Si el servicio cuenta con una interfaz cliente-servidor, podrás enlazar el servicio desde un componente pasando una intención como parámetro del método bindService().
  
  
• Para la entrega de avisos (BroadcastReceiver). Un aviso es un mensaje que cualquier aplicación podrá recibir y que se genera como consecuencia de un evento concreto. El sistema avisa de ciertos eventos tales como que el sistema está arrancando, o que se ha iniciado la carga de batería. Podremos enviar avisos a otras aplicaciones pasando una intención como parámetro de los métodos sendBroadcast(), sendOrderedBroadcast(), o sendStickyBroadCast().
  

El editor de plantillas

Android Studio cuenta con un editor avanzado de plantillas que nos permitirá añadir widgets fácilmente a nuestros diseños con una simple acción de pinchar y arrastrar. También contaremos con una vista previa de las modificaciones que vayamos haciendo en el código fuente (XML) de nuestras plantillas.

El editor soporta dos modos de visualización: una vista en modo texto donde podrás modificar el código XML tal cual, y una vista en modo diseño más visual.

Creando un Proyecto

Android Studio facilita la creación de aplicaciones para múltiples dispositivos: teléfonos, tabletas, televisores, relojes y Google Glass. El asistente de creación de creación de proyectos, nos permitirá elegir el o los dispositivos para los que queramos crear una aplicación y será el encargado de generar todo lo necesario para que empecemos nuestro desarrollo.

Requerimientos del sistema

Windows®.

• Microsoft® Windows® 8/7/Vista/2003 (32 o 64 bit).
• RAM mínima: 2 GB. RAM recomendada: 4 GB.
• 400 MB de espacio en disco para Android Studio y 1 GB para el SDK de Android (imágenes para dispositivos virtuales).
• Resolución de pantalla mínima: 1280 x 800.
• Java Development Kit (JDK) 7.
• Opcionalmente y para la emulación acelerada basada en chips Intel: Intel® processor with support for Intel® VT-x, Intel® EM64T (Intel® 64), and Execute Disable (XD) Bit functionality.

Mac® OS X®.

• Mac® OS X® 10.8.5 o superior y hasta la versión 10.9 (Mavericks).
• RAM mínima: 2 GB. RAM recomendada: 4 GB.
• 400 MB de espacio en disco para Android Studio y 1 GB para el SDK de Android (imágenes para dispositivos virtuales).
• Resolución de pantalla mínima: 1280 x 800.
• Java Runtime Environment (JRE) 6.
• Java Development Kit (JDK) 7.
• Opcionalmente y para la emulación acelerada basada en chips de Intel: Intel® processor with support for Intel® VT-x, Intel® EM64T (Intel® 64), and Execute Disable (XD) Bit functionality.

Ejecuta Android Studio con el JRE 6 para optimizar el renderizado de fuentes. Puedes configurar tus proyectos para que usen la versión 6 o 7 del JDK.

Linux.

• Compatible con los escritorios GNOME y KDE.
• Biblioteca para C de GNU (glibc) 2.11 o posterior.
• RAM mínima: 2 GB. RAM recomendada: 4 GB.
• 400 MB de espacio en disco para Android Studio y 1 GB para el SDK de Android (imágenes para dispositivos virtuales).
• Resolución de pantalla mínima: 1280 x 800.
• Java Development Kit (JDK) 7.
• Opcionalmente y para la emulación acelerada basada en chips de Intel: Intel® processor with support for Intel® VT-x, Intel® EM64T (Intel® 64), and Execute Disable (XD) Bit functionality.

Probada sobre Ubuntu® 12.04, Precise Pangolin (versión de 64 bit capaz de ejecutar aplicaciones de 32 bit).

Instalando Android Studio

Android Studio cuenta con todo lo necesario para empezar a desarrollar aplicaciones: incluye las herramientas del SDK y el IDE con la tecnología de IntelliJ.

Si aún no has descargado Android Studio, puedes consultar el artículo "Obteniendo Android Studio".

Antes de instalar Android Studio, asegúrate de tener instalado la versión 6 o superior del JDK (solo con el JRE no será suficiente). Para comprobar si tienes el JDK instalado y qué versión, abre un terminal y escribe javac -version. Si el JDK no está disponible o la versión es inferior a la 6, descarga el JDK correspondiente a tu plataforma.

Añadiendo paquetes al SDK

Por defecto, el SDK de Android no incluye todo lo que necesitamos para empezar nuestros desarrollos. El SDK distingue entre herramientas, plataformas y otros elementos que podremos descargar conforme los vayamos necesitando a través del gestor de paquetes. Por tanto, antes de empezar, tendremos que añadir una serie de paquetes necesarios a nuestro SDK.

Para empezar a añadir paquetes, ejecutaremos el gestor de paquetes de cualquiera de las siguientes formas:

• Desde la pantalla de bienvenida de Android Studio: Configure > SDK Manager.
• Si ya disponemos de un proyecto abierto, desde la barra de herramientas pulsando el botón , o bien, seleccionando la opción de menú Tools > Android > SDK Manager.
• Si estamos en Windows, ejecutando el archivo SDK Manager.exe desde el directorio raíz del SDK.
• Si estamos en Mac/Linux, abriendo un terminal, yendo al directorio tools/ del SDK y ejecutando el comando android sdk.

Actualizando Android Studio

Si ya dispones de una versión instalada de Android Studio,  puedes actualizar a la última versión instalando un parche. Desde el propio Android Studio, selecciona la opción de menú Help > Check for Updates (en Mac, Android Studio > Check for Updates) para ver si existen actualizaciones pendientes. En la mayoría de los casos funcionará. Ten en cuenta que estamos trabajando con una versión beta.

Si por alguna razón no se encuentra disponible la nueva versión, procede a descargarlo manualmente.

Importante. Si reemplazas una versión previamente instalada, el proceso de instalación de la nueva versión eliminará cualquier paquete del SDK que te hayas descargado con anterioridad. Para conservarlos, haz una copia del directorio del SDK a una carpeta temporal antes de instalar la actualización. Una vez se haya instalado, restaura la copia. Si por alguna razón algo hubiera fallado durante el proceso de copia, vuelve a descargar el SDK a través del gestor de paquetes.

Para instalar paquetes adicionales como imágenes adicionales de Android para el emulador u otras bibliotecas que no están disponibles por defecto en el SDK, utiliza el gestor de paquetes. Puedes abrirlo desde la pantalla de bienvenida de Android Studio: Configure > SDK Manager, o bien, si ya dispones de un proyecto abierto , pulsando el botón de la barra de herramientas, o seleccionando la opción de menú Tools > Android > SDK Manager.

Obteniendo Android Studio

Android Studio. Detalle del editor de plantillas.

Android Studio es el nuevo entorno de desarrollo de Android basado en tecnología IntelliJ IDEA. Posee una serie de características y mejoras sobre Eclipse ADT y acabará siendo el IDE oficial de Android una vez éste, esté listo. Además de las cualidades que nos ofrece como producto basado en IntelliJ, Android Studio nos nos proporciona:

• Gradle como sistema de compilación y generación de paquetes.
• Definición de varios entornos de ejecución y la generación de un APK para cada uno de ellos.
• Plantillas predefinidas para los servicios de Google y para varios dispositivos.
• Editor de plantillas con soporte para la edición de temas.
• Lint como herramienta para obtener mejoras en el rendimiento, usabilidad, compatibilidad entre versiones y otros problemas.
• ProGuard y firma de aplicaciones.
• Soporte integrado para la nube de Google.

Componentes de una aplicación

Los componentes son la esencia en la construcción de una aplicación Android. Cada componente puede comportarse como un punto de entrada en nuestra aplicación. No todos los componentes serán puntos de entrada, algunos dependerán de otros, pero cada uno de ellos juegan su propio papel y en conjunto definirán el comportamiento de nuestra aplicación.

Permisos del sistema

Android es un sistema operativo en el las aplicaciones se ejecutan de manera aislada y cuentan con su propia identidad (un ID de usuario y un ID de grupo Linux). Partes del sistema también cuentan con su propia identidad. De este modo, Linux aísla las aplicaciones entre sí y del propio sistema.

Adicionalmente, existen otros mecanismos basados en permisos que podremos otorgar de manera explícita a un proceso sobre ciertos datos, o también, podremos especificar que una URI (enlace a contenido) sea accesible temporalmente.

Recursos

Una aplicación Android está compuesta no solo por su código, a su vez, ésta cuenta con recursos de imagen, audio y vídeo, o cualquier otra cosa relacionada con su aspecto visual: animaciones, menús, estilos, colores o el diseño de una actividad. La utilización de recursos nos facilitará su mantenimiento y nos permitirá su optimización para diferentes configuraciones de dispositivo: idioma, tamaño de pantalla, etc.

Compatibilidad y dispositivos

Android ha sido diseñado para ser ejecutado en múltiples tipos de dispositivos, desde teléfonos móviles a tabletas y televisores inteligentes (smart TV). Como desarrollador, esta amplia gama de dispositivos te ofrece la oportunidad de llegar a un alto número de usuarios desde tu aplicación. Para que tu aplicación tenga éxito, ésta deberá ser lo suficientemente flexible y contar con una interfaz de usuario que sea capaz de adaptarse a cada una de las configuraciones de pantalla existentes.

Para facilitarnos el camino y conseguir dicho objetivo, Android nos ofrece la posibilidad de poder especificar diferentes diseños y recursos de manera estática para cada configuración específica de dispositivo. Por ejemplo, podremos especificar diferentes diseños usando varios archivos XML, atendiendo al tamaño de pantalla. En este caso, Android cargará el diseño más adecuado en función de las características del dispositivo en el que se esté ejecutando nuestra aplicación.

El archivo AndroidManifest.xml

Puesto que el sistema Android es el intermediario de atender las intenciones cada vez que se pretende activar un componente, éste debe saber de la existencia de dichos componentes. Es aquí cuando el archivo especial AndroidManifest.xml entra en juego. Nuestra aplicación tendrá que declarar todos sus componentes en este archivo que se encuentra ubicado en el directorio raíz de nuestro proyecto (generalmente /app/src/main/AndroidManifest.xml).

Este archivo sirve, además, para otros propósitos tales como:

• Identificar los permisos que nuestra aplicación requiere por parte del usuario. Como por ejemplo, tener acceso a Internet o poder consultar la agenda de contactos.
• Declarar la versión mínima de API que nuestra aplicación necesita para funcionar.
• Declarar características software y hardware que nuestra aplicación necesitará para funcionar. Por ejemplo, cámara, bluetooth o pantalla multi táctil.
• Librerías enlazadas y necesarias para un correcto funcionamiento. Por ejemplo, la librería de mapas de Google.
• Y más ...

Nota. En Android Studio, el punto segundo y cuarto de la lista anterior, se configura desde el archivo /app/build.gradle.

Introducción a Android

Android nos proporciona un completo entorno de trabajo de desarrollo que nos ayudará en la elaboración de aplicaciones para dispositivos móviles. En la mayoría de los casos, utilizaremos Java como lenguaje de programación.

Las aplicaciones en Android se construyen mediante la combinación de distintos componentes que pueden ser invocados de manera individual. Por ejemplo, una actividad (Activity) puede mostrar una pantalla de la interfaz del usuario, mientras que un servicio (Service), y de manera independiente, puede realizar ciertas operaciones en segundo plano. Actividad y servicio son dos de los componentes Android que desarrollaremos en profundidad más adelante.