jueves, 29 de noviembre de 2007

Manos a la obra - Anatomía de una aplicación Android

Documento original: Anatomy of an Android Application

Anatomía de una aplicación Android

[Título original: Anatomy of an Android Application]

Las aplicaciones Android están constituidas a partir de la combinación de los siguientes bloques:

  • Activity
  • IntentReceiver
  • Service
  • ContentProvider
  • NOTA: Una aplicación no requiere utilizar todos estos componentes.

    Una vez que has seleccionado los componentes que utilizarás en tu aplicación, es necesario que los listes en un archivo llamado: "AndroidManifest.xml". Este es un archivo XML en el que declaras los componentes de tu aplicación, sus capacidades y sus requerimientos.

    Actividad

    [Título original: Activity]

    Una "actividad" es el bloque más usado en las aplicaciones "Android". Generalmente, una "actividad" es una pantalla individual en tu aplicación. Cada "actividad" se implementa como una clase que hereda de "Activity", lo que hará que tu clase despliegue una UI compuesta de "View"s y resonda a eventos. Lo común es que una aplicación consista de múltiples pantallas. Por ejemplo, una aplicación de mensajería podría usar una pantalla para mostrar el listado de contactos y en una segunda pantalla para escribir el mensaje al contacto seleccionado; y otras pantallas para ver cambiar la configuración. Cada una de estas pantallas debe ser implementada como una "Activity". La navegación entre las pantallas se hace iniciando una nueva "Activity". En algunos casos, una "Activity" podría devolver un valor a la "Activity" anterior, por ejemplo la "Actividad#1" podría permitir seleccionar una foto y esta foto sería devuelta a la "Activity" que hizo el llamado a "Actividad#1".

    Cuando una pantalla es abierta, la previa es puesta en pausa y agregada al "History Stack". Posteriormente, el usuario puede navegar hacia previas pantallas invocando las pantallas almacenadas en el "History Stack". Las pantallas también pueden ser removidas del "History Stack" cuando resulta inapropiado su almacenamiento. Android mantiene un "History Stack" por cada una de las aplicaciones que son activadas desde la "Home Screen".

    Intentos y filtros de intentos

    [Título original: Intent and Intent Filters]

    Android usa una clase especial llamada "Intent" para moverse de una pantalla a otra. Un "Intent" describe lo que una aplicación desea hacer. Las dos partes más importantes de la estructura de datos de un "Intent" son la acción y los datos sobre los cuales se actuará. Los valores típicos para la acción son "MAIN", "VIEW", "PICK", "EDIT", etc. Los datos son expresados como una URI. Por ejemplo, para ver la información de contacto de una persona podría ser necesario crear un "Intent" con la acción "VIEW" y los datos definidos como una URI que representa a esa persona.

    Una clase relacionada con "Intent" es "IntentFilter". Si bien un "Intent" es una solicitud para realizar algo, un "IntentFilter" es una descripción de lo que intenta hacer una "Activity" (o de lo que intenta recibir). Una "Activity" que es capaz de desplegar la información de contacto de una persona podría declarar que sabe cómo tratar la acción "VIEW" cuando es aplicada a los datos que representan a la persona. Una "Activity" declara sus "IntentFilter"s en el archivo "AndroidManifest.xml".

    La navegación de pantalla a pantalla es ejecutada a través de la resolución de intentos. Para navegar hacia adelante, una "Activity" llama "startActivity(myIntent)". Entonces, el sistema examina todos los "IntentFilter"s que existen para las aplicaciones instaladas y toma aquellas "Activity" cuyos "IntentFilter" mejor se acercan a "myIntent". La nueva "Activity" es informada del "Intent", lo que causa que sea activada. El proceso de resolución de "Intent" ocurre en tiempo de ejecución cuando "startActivity" es llamado, lo cual tiene dos beneficios claves:

  • Una "Activity" puede reutilizar funcionalidades de otras componentes con sólo hacer un una solicitud en la forma de "Intent".

  • Una "Activity" puede ser reemplazada en cualquier momento por una nueva "Activity" que tenga un "IntentFilter" equivalente.

  • Recibidor de intento

    [Título original: Intent Receiver]

    Tú puedes utilizar un "IntentReceiver" cuando quieras programar tu aplicación para que se ejecute como respuesta a un evento. Por ejemplo, cuando recibes una llamada, cuando la red de datos esta disponible o cuando es media noche. Los "IntentReceiver"s no despliegan UI, sin embargo ellos podrían utilizar el "NotificationManager" para avisar al usuario que algo interesante está pasando. Los "IntentReceiver"s son registrados en el archivo "AndroidManifest.xml", pero también pueden ser registrados programáticamente con el uso de "Context.registerReceiver()". Tu aplicación no requiere estar corriendo para que sus "IntentReceiver"s puedan ser llamados. Si tu aplicación no estuviera corriendo, el sistema la puede activar cuando uno de sus "IntentReceiver"s sea gatillado. Las aplicaciones también pueden transmitir sus propios "Intent"s a otras aplicaciones a través de "Context.broadcastIntent()".

    Servicios

    [Título original: Service]

    Un "Service" es una aplicación que se mantiene activada por un largo tiempo y no despliega una UI. Un ejemplo es un programa que reproduce archivos mp3 desde una lista de música, mientras el usuario realiza otras actividades. En este caso, el programa podría iniciar un servicio con "Context.startService()" y de esa forma reproducir la música sin necesidad de usar la pantalla. El sistema mantendrá el servicio de reproducción de música corriendo hasta que finalice. Si quieres aprender más sobre la prioridad que es dada a los servicios por el sistema, lee "Ciclo de vida de una aplicación Android". Es posible conectarse a un "Service" (y activarlo si no estuviera corriendo) haciendo uso del método "Context.bindService()". Una vez que la aplicación está conectada al servicio, la comunicación entre tu aplicación y el servicio se realiza a través de la interfaz que el "servicio" expone. Para nuestro ejemplo del reproductor mp3, está interfaz podría permitir hacer pausa o saltar a una nueva canción.

    Proveedor de contenidos

    [Título original: Content Provider]

    Las aplicaciones puedes almacenar sus datos en archivos, una base de datos "SQLite" o cualquier otro mecanismo. Sin embargo, un "Content Provider" es de utilidad cuando los datos de tu aplicación deben ser compartidos con otras aplicaciones. Un "Content Provider" es una clase que implementa un conjunto estándar de métodos para que otras aplicaciones almacenen o recuperen el tipo de datos que el "Content Provider" manipula.

    lunes, 26 de noviembre de 2007

    Manos a la obra - Hola Androide

    Hola Androide

    La mejor forma de hacerse una primera impresión del entorno de desarrollo de Android es experimentando que tan fácil es crear la famosa aplicación: "Hola Mundo" al estilo Android.

    Descripción genérica del proceso

    La creación de un proyecto Android Eclipse es realmente sencillo, esta es una descripción del proceso a grandes rasgos:
    1. Crea un nuevo "Android Project" seleccionando del menú principal File > New > Project.
    2. Ingresa la información con el detalle del proyecto en el cuadro de diálogo "New Android Project".
    3. Modifica el código de la plantilla auto-generada para que despliegue el mensaje "Hola Mundo".

    Creación del proyecto

    Desde el menú principal selecciona "File > New > Project". Si el "Android Plugin" para Eclipse fue correctamente instalado, debería abrirse el cuadro de diálogo "New Project" y deberías ver el elemento llamado "Android" y al expandirlo deberías ver el subelemento llamado "Android Project".

    [agregar imagen]

    Después de seleccionar "Android Project", pressiona el botón "Next".

    Información del proyecto

    En el cuadro de diálogo "New Android Project" debes ingresar la información relevante del proyecto. La siguiente figura es un ejemplo:

    [agregar imagen]

    A continuación está la descripción de cada uno de los datos que debes ingresar:

    • Project Name : Este es el nombre del directorio en tu computador que contendrá los archivos del proyecto.
    • Package Name : Este es el "package namespace" (es el mismo concepto de "package" en Java). Esto también fijará el nombre del "package" que será utilizado al momento de generar el "stub" de la "Activity". El nombre del "package" utilizado en tu aplicación debe ser único y distinto a todos aquellos intalados en el sistema, por esta razón es muy importante utilizar nombres de "packages" en un formato estándar de dominios. En este ejemplo, utilizaré el nombre de dominio "com.northvortex.android" y tú deberías utilizar uno diferente y apropiado a tu organización.
    • Activity Name : Este es el nombre de la clase que será generada por el "plugin". Esta clase será una subclase de "Activity". Una "Activity" es simplemente una clase que puede ejecutarse y realizar una tarea. Puede crear una UI si lo deseas, pero no es necesario.
    • Application Name : Este es el nombre con el cual tu aplicación será conocida por los usuarios.
    • Use default location : este checkbox permite cambiar la ubicación en el disco donde los archivos del proyecto serán generados y almacenados.
    Revisión del código fuente generado

    El código fuente que será generado para la aplicación "Hola Androide" será el siguiente:

    public class HolaAndroide extends Activity
    {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle icicle)
    {
    super.onCreate(icicle);
    setContentView(R.layout.main);
    }
    }

    Edición del código fuente

    El siguiente código muestra la aplicación modificada para que despliegue el mensaje "Hola Androide".

    import android.widget.TextView;
    public class
    HolaAndroide extends Activity
    {

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle icicle) {
    super.onCreate(icicle);
    TextView tv = new TextView(this);
    tv.setText("Hola Androide");
    setContentView(tv);
    }
    }

    Descripción de los cambios en el código

    El primer cambio corresponde a "import android.widget.TextView;", la cual es necesaria para utilizar la clase "TextView".

    NOTA: En Android, la interfaz de usuario está compuesta de un jerarquía de clases llamadas "Views. Una "View" es simplemente un objeto que puede ser pintado en la pantalla, tal como una animación o un botón. El nombre específico para la subclase de "View" que manipula texto es "TextView".

    Esta es la sintaxis para crear un objeto "TextView":

    TextView tv = new TextView(this);

    El argumento para el constructor de "TextView" es una instancia de "Context". Un "Context" es simplemente un enlace hacia el sistema y es lo que provee el acceso a recursos como bases de datos, preferencia entre otras cosas. La clase "Activity" hereda de "Context" y debido a que nuestra aplicación es un subclase de "Activity", entonces también lo es de Context", de ese modo podemos pasar "this" como argumento al constructor de "TextView".

    A continuación indicamos que texto deseamos desplegar:

    tv.setText("Hello, Android");

    Con la siguiente línea, conectamos la "TextView" con la pantalla:

    setContentView(tv);

    El método "setContentView()" (de "Activity") le indica indica al sistema que "View" debe ser asociada con la UI de la "Activity". Si una "Activity" no llama a este método ninguna UI será presentada y el sistema simplemente mostrará una pantalla en blanco.

    Ejecución de la aplicación

    "Eclipse plugin" hace muy sencilla la ejecución de tus aplicaciones. Comienza abriendo el cuadro de diálogo "Run", para ello selecciona "Run > Open Run Dialog". La siguiente figura muestra este cuadro:



    A continuación expande el elemento "Android Application" y presiona el ícono mostrado en la siguiente figura:



    o simplemente haz doble clic in el elemento "Android Application". Como resultado de esto deberías tener un nuevo elemento bajo "Android Application" llamado "New_configuration".

    Ingresa en la casilla de texto algo que identique tu aplicación, para nuestro ejemplo será "Hola, Androide" y luego selecciona tu proyecto usando el botón "Browse". El plugin automáticamente va a revisar tu proyecto y buscar todas las "Activity" para así llenar el combo box "Activity:". Selecciona de este combo box la "Activity" principal. Finalmente, presiona el botón "Apply".

    Ahora presiona el botón"Run" y el "Android Emulator" debería activarse. Una vez que esté activo, tu aplicación debería aparecer y verse similar a como muestra la siguiente figura:



    Cambios en la UI a través del "XML Layout"

    La UI de la aplicación que hemos programado fue creada "programáticamente". Esto significa que la UI de una aplicación puede ser construida invocando operaciones de las API. Este enfoque tiene las siguientes deficiencias: un pequeño cambio en el diseño de la pantalla puede resultar en grandes dolores de cabeza. Además, es muy fácil olvidar conectar las "Views "; lo cual puede causar errores en el despliegue de datos en la pantalla y pérdida de tiempo depurando la aplicación.

    Para evitar lo descrito anteriormente es que "Android" provee un modelo alternativo para la construcción de la UI de una aplicación. Este nuevo enfoque es llamado"XML-based layout". La forma más sencilla de explicar este concepto es mostrar un ejemplo.

    A continuación se muestra un archivo XML que describe un diseño idéntico al que construimos a través del enfoque programático:

    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:text="Hola Androide"/>

    La estructura general de un archivo "Android XML layout" es sencilla: es un árbol de etiquetas y cada etiqueta es el nombre de una de las clases "View". En este ejemplo, la estructura del archivo sólo tiene un elemento: un TextView.

    El los archivo "Android XML layout", es posible utilizar etiquetas con el nombre de cualquier clase que herede de "View". Esto incluye el nombres de las clases que tú mismo hayas creado. El uso de archivos "Android XML layout" hace mucho más fácil y rápida la construcción de UI en comparación lo que tendrías que hacer si lo hicieras programáticamente. Este modelo está inspirado en el "web development model", el te permite separar la presentación de tu aplicación (su UI) de la lógica utilizada para manipular los datos.

    A continuación está un breve descripción de los atributos empleados en el archivo
    "Android XML layout" de este ejemplo.
    • xmlns:android : esto corresponde a la declaración de un "XML namespace" y le indica a las herramientas de "Android" que haremos referencia a atributos definidos en el "Android namespace". La etiqueta raíz de cada archivo "Android XML layout" debe tener este atributo.
    • android:layout_width : este atributo indica el espacio a lo ancho que este elemento utilizará en la pantalla. En nuestro ejemplo, como tenemos un sólo elemento haremos que ocupe toda la pantalla, por esta razón su valor es "fill_parent" means.
    • android:layout_height : este es similar a "android:layout_width", pero se refiere a la altura.
    • android:text : este atributo define el texto que el elemento "TextView" va a contener inicialmente.
    NOTA: Los archivos "XML layout" deben almacenarse en el subdirectorio "res/" del directorio de tu proyecto. Además, en este subdirectorio debemos almacenar todos aquellos archivos que no son de código fuente, esto incluye imágenes, textos regionalizados y los archivos "XML layout". El nombre "res" es la abreviación para "resources".

    El "Eclipse plugin" crea automáticamente uno de estos archivos para tu proyecto. En nuestro ejemplo, nosotros simplemente no hicimos uso de él. A continuación modificaremos el archivo "XML layout" de nuestro proyecto, para ello en la ventana "Package Explorer" expande el elemento "res/layout" y reemplaza el contenido del archivo "main.xml" con el texto XML descrito anteriormente.

    Ahora, en la ventana "Package Explorer", expande el elemento "src" y edita el archivo "R.java". Debería ser verse como el siguiente código:

    /* AUTO-GENERATED FILE. DO NOT MODIFY.
    *
    * This class was automatically generated by the
    * aapt tool from the resource data it found. It
    * should not be modified by hand.
    */

    package com.patatas;

    public final class R {
    public static final class attr {
    }
    public static final class drawable {
    public static final int icon=0x7f020000;
    }
    public static final class layout {
    public static final int main=0x7f030000;
    }
    public static final class string {
    public static final int app_name=0x7f040000;
    }
    }

    El archivo "R.java" es un índice a todos los recursos definidos en el proyecto. Esta clase sirve de abreviación al momento de referenciar cualquier recurso que hayas definido en tu proyecto. Esta característica resulta muy poderosa en combinación con las facilidades de autocompletación de Eclipse, porque te permite rápidamente e interactivamente localizar las referencias que estás buscando.

    Por ahora, lo más importante es fijar la atención en la clase llamada "layout" y su miembro llamado "main". "Eclipse plugin" se dió cuenta que agregaste un archivo "XML layout" y por lo tanto regeneró el archivo "R.java". En la medida que agregues nuevos recursos a tu proyecto, notarás que el archivo "R.java" es actualizado para reflejar los cambios.

    La última cosa que necesitas modificar es el código fuente de "HolaAndroide" para indicar que utilizarás el "XML layout" para la UI de la aplicación.

    NOTA: Cuando hagas este cambio, utiliza las facilidades de Eclipse para autocompletación, de esa forma el use la clase "R" te parecerá más interesante.

    A continuación está el nuevo código y como ves es mucho más sencillo:

    public class HelloAndroid extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle icicle) {
    super.onCreate(icicle);
    setContentView(R.layout.main);
    }
    }

    Ahora que haz hecho el cambio, vuelve a ejecutar la aplicación. Cuando la aplicación se active, tú deberías ver exactamente la misma UI que tenías anteriormente.

    Para más información sobre "XML layouts" lee "Implementado la interfaz de usuario".

    Depurando nuestra aplicación

    "Android Plugin" para Eclipse está muy bien integrado con "Eclipse debugger". Para demostrarlo, introduciremos un error en nuestro código y posteriormente depuraremos el código para encontrar el error. Cambia el código fuente de la siguiente forma:

    public class HelloAndroid extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); Object o = null; o.toString(); setContentView(R.layout.main); } }

    Este cambio hará que nuestra aplicación genere un "NullPointerException". Si corres el programa deberías ver algo como esto:



    Para encontrar el error, fija un "breakpoint" en el código fuente en la línea "Object o = null;" Luego, seleccionar Run > Debug Last Launched para entrar en modalidad de depuración(debug mode). Tu aplicación va a reiniciar el emulador, pero esta vez se suspenderá antes de llegar al "breakpoint" que tú fijaste. Desde ese momento, puedes comenzar a ejecutar el código línea a línea dentro de la perspectiva "Debug" de Eclipse, tal como lo harías con cualquier otra aplicación.

    Manos a la obra - Instalación del SDK

    Documento original: Installing the SDK

    Instalando el SDK

    [Título original: Installing the SDK]

    A continuación se encuentran las instrucciones necesarias para instalar "Android SDK" y configurar tu entorno de desarrollo.

    Utiliza el siguiente link para nevegar a la página desde la cual podrás bajar el software necesario : Descarga de Android SDK.

    Requerimiento de sistema operativo y software

    [Título original: System and Software Requirements]

    Para desarrollar aplicaciones Android usando el código y herramientas del "Android SDK" es necesario que tu computador y entorno de desarrollo cumplan con los siguientes requerimientos.

    Sistemas operativos soportados

    [Título original: Supported Operating Systems]

  • Windows XP o Vista

  • Linux (probado en Linux Ubuntu Dapper Drake)

  • Mac OS X 10.4.8 o superior (sólo x86)

  • Entornos de desarrollo

    [Título original: Supported Development Environments]

    Eclipse IDE

    [Título original: Eclipse IDE]

  • Eclipse 3.2, 3.3 (Europa)

  • Eclipse JDT Plugin.

  • JDK 5 ó JDK 6 (JRE por sí solo no es suficiente)

  • No es compatible con Gnu Compiler para Java (gcj)

  • Otros entornos de desarrollo

    [Título original: Other development environments or IDEs]

  • JDK 5 o JDK 6 (JRE por sí solo no es suficiente)

  • No es compatible con Gnu Compiler para Java (gcj)

  • Apache Ant 1.6.5 o superior para Linux y Mac

  • NOTA: Si JDK ya está instalado en tu computador, debes verificar que la versión que tienes cumple con los requerimientos descritos. Generalmente, las distribuciones Linux incluyen JDK 1.4 o Gnu Compiler para Java; los cuales no tienen soporte en el entorno de desarrollo de Android.

    Instalando el SDK

    [Título original: Installing the SDK]

    Después de bajar el "SDK", extrae el contenido del archivo ".zip". Por omisión, los archivos del "SDK" serán extraídos en un directorio llamado: android_sdk_<platform>_<release>_<build>. (ejemplo: android_sdk_windows_m3-rc20a). Este directorio contendrá los siguientes subdirectorios: "tools/", "samples/" y "docs/"

    NOTA: Posteriormente, cuando configuremos el "Android plugin" o usemos las "SDK tools", nos referiremos a este directorio como el "SDK directory".

    Opcionalmente, puedes agregar a la variable de entorno "path" el directorio "tools/". Como está mencionado anteriormente, este directorio está ubicado dentro del "SDK directory" y lo llamaremos "SDK tools directory".

  • Linux : edita tu archivo "~/.bash_profile" o "~/.bashrc". Busca la línea que modifica la variable de entorno "PATH" y agrega la ubicación completa del "SDK tools directory". En caso que no exista esa línea, agrega lo siguiente:

    export PATH=${PATH}:<your_sdk_dir>/tools

  • Windows : haz clic en "My Computer" y selecciona "Properties". En la lengüeta "Advanced" presiona el botón "Environment Variables" y en el cuadro que diálogo que se abrirá haz doble clic en "Path" que está en el cuadro "System Variables". Finalmente, agrega la ubicación completa del "SDK tools directory".

  • NOTA: El hecho de agregar el "SDK tools directory" a tu "path" te permitirá ejecutar el "Android Debug Bridge (adb)" y otras herramientas de comandos de línea sin la necesidad de escribir la ubicación completa del "SDK tools directory". Si posteriormente actualizas el "SDK", debes también actualizar el valor de la variable "PATH" con la ubicación de la nueva actualización del "SDK".

    Instalación del Eclipse Plugin - ADT

    [Título original: Installing the Eclipse Plugin - ADT]

    Si actualmente utilizas "Eclipse IDE" como tu entorno de desarrollo Java, te recomiento que instales el "plugin" llamado "Android Development Tools (ADT)", el cual provee soporte y acceso integrado para los proyectos Android y las herramientas del "SDK". El "ADT plugin" incluye una variedad de extensiones que te permitirán crear, ejecutar y depurar aplicaciones Android de una manera fácil y rápida.

    NOTA: Si tu no vas a usar "Eclipse IDE", no es necesario que bajes e instales "ADT plugin".

    A continuación se describe paso a paso las instrucciones necesarias para bajar e instalar el "ADT plugin" y configurar Eclipse para realizar la actualización del plugin desde su sitio de publicación.

  • Inicia Eclipse, luego selecciona "Help > Software Updates > Find and Install...".

  • En el cuadro de diálogo que aparece, selecciona "Search for new features to install" y presiona el botón "Next".

  • Presiona el botón "New Remote Site...".

  • En el cuadro de diálogo, ingresa un nombre para el sitio remoto (por ejemplo: "Android Plugin") e ingresa la siguiente URL:

    https://dl-ssl.google.com/android/eclipse/
    y presiona el botón "OK".

  • Ahora deberías ver "Android Plugin" agregado a la lista de búsqueda y además debería estar seleccionado. Presiona el botón "Finish". Esto abrirá el cuadro de diálogo "Updates".

  • En el cuadro de diálogo "Updates", marca la casilla de selección para "Android Plugin" y presiona el botón "Next".

  • Lee el "ANDROID SOFTWARE DEVELOPMENT KIT LICENSE AGREEMENT" y si estas de acuerdo, entonces selecciona "I accept terms of the license agreement". Presiona el botón "Next".

  • Presiona el botón "Finish". El "ADT Plugin" comenzará a descargarse.

  • El "ADT plugin" no está firmado pero igual puedes aceptar la instalación presionando el botón "Install All".

  • Reinicia Eclipse.

  • Después de reiniciar Eclipse, selecciona "Window > Preferences..." (esto abrirá el cuadro de diálogo "Preferences"). Luego haz clic en el elemento "Android". A continuación actualiza la casilla de texto "SDK Location" con el directorio "SDK directory". Finalmente, presiona el botón "Apply" y el botón "OK".

  • Actualización del ADT Plugin

    [Título original: Updating the ADT Plugin]

    Sigue las siguientes instrucciones para actualizar el "ADT plugin" con la última versión:

  • Selecciona "Help > Software Updates > Find and Install...."

  • Selecciona Search for updates of the currently installed features y presiona Finish.

  • Si hubiese disponible una nueva actualización del ADT, selecciónala e instálala.

  • Otra alternativa es:

  • Selecciona Help > Software Updates > Manage Configuration.

  • Expande el árbol y selecciona el elemento Android Development Tools [versión]

  • Selecciona Scan for Updates bajo Available Tasks.

  • Consejo para descargar ADT

    [Título original: Tips for downloading ADT]

    Si estás teniendo problemas para descargar ADT plugin después de haber seguido los antes antes mencionados, aquí tienes algunas sugerencias:

  • En el paso 4, intenta usar http en vez de https en la URL del sitio remoto.

  • Si tú estás detrás de un firewall (tal como un firewall corporativo), asegúrate que tú tienes apropiadamente configurado tu proxy en Eclipse. En Eclipse 3.3, tú puedes configurar tu información de proxy desde el menú principal "Window > Preferences > General > Network Connections". En Eclipse 3.2, usa "Window > Preferences > Install/Update".

  • Si aún después de lo anterior no logras descargar el ADT plugin a través de Eclipse, sigue los siguientes pasos para descargar e instalar el plugin desde tu computador:

  • Descarga el archivo ZIP del ADT

  • Descomprime el archivo ZIP en su propio directorio

  • Sigue los pasos 1 y 2 de las instrucciones estándard mencionadas anteriormente

  • Presiona "New Local Site..."

  • En el cuadro de diálogo, selecciona el directorio donde descomprimiste el archivo ZIP

  • Sigue los pasos 5 hasta el 11 de las instrucciones estándard mencionadas anteriormente para completar la instalación

  • NOTA: Para actualizar el plugin tendrás que seguir estos mismos pasos en vez de las instrucciones estándard de instalación

    Desarrollando aplicaciones Android con Eclipse

    [Título original: Developing Android Applications on Eclipse]

    El primer paso en el desarrollo de una aplicación Android con "Eclipse IDE" es crear un proyecto Android y luego configurar la ejecución de la aplicación. Después de esto, puedes escribir, ejecutar y depurar tu aplicación.

    La sección a continuación provee instrucciones asumiendo que tu haz instalado el ADT plugin en tu entorno Eclipse. Si tú no lo haz instalado, deberías hacerlo antes de continuar con las siguientes instrucciones. Lee "Actualización del ADT Plugin [falta link]" para más información.

    Creación de un proyecto Android

    [Título original: Creating an Android Project]

    El "ADT plugin" provee un "New Project Wizard" que puede ser utilizado para crear rapidamente un proyecto Eclipse nuevo o uno a partir de código existente. Para crear el proyecto sigue las siguientes instrucciones:

  • Selecciona "File > New > Project"

  • Selecciona Android > Android Project, y presiona Next, esto abrirá el cuadro de diálogo "New Android Project".

  • En la casilla de texto "Project name" ingresa el nombre del proyecto. En el marco llamado "Contents" selecciona Create new project in workspace para así crear un nuevo proyecto. En el marco llamado "Properties", ingresa el nombre del paquete base ("Package name"), el nombre de tu "Activity" ("Activity name") para crear su correspondiente archivo ".java" y un nombre con el cual será conocida tu aplicación ("Application name"). En el marco llamado "Contents" selecciona Create project from existing source para así crear un proyecto basado en código que ya existe. Usa esta opción si tú quieres construir y ejecutar cualquiera de las aplicaciones de ejemplo incluidas en el SDK. Las aplicaciones de ejemplo están ubicadas en el directorio "samples/" del "SDK directory". Navega al directorio que contiene los archivos fuentes y clic OK. Si el directorio contiene un archivo "Android manifest" válido, el "ADT plugin" llenará automáticamente las casillas de texto para "Package name", "Activity name" y "Application name".

  • Presiona Finish.

  • Después de realizado los pasos anteriores podrás ver los siguientes directorios y archivos en la estructura de tu proyecto:

    src/ un directorio que contiene el archivo ".java" para tu "Activity".
    res/ un directorio que contendrá los recursos de tu aplicación.
    AndroidManifest.xml Este es el archivo "Android manifest" de tu proyecto.

    Configurando la activación de una aplicación Android

    [Título original: Creating a Launch Configuration]

    Para poder ejecutar o depurar una aplicación desde Eclipse debes definir una "launch configuration" para ella. Una "launch configuration" indica qué proyecto activar, qué "Activity" iniciar y las opciones que utilizará el emulador, etcétera.

    Para definir una "launch configuration" para tu aplicación sigue las siguientes instrucciones:

  • Selecciona "Run > Open Run Dialog... o Run > Open Debug Dialog...", según corresponda.

  • En la lista de tipos de proyectos ubica "Android Application" y abre su menú de contexto (clic con botón derecho) y selecciona la opción New.

  • En la casilla de texto "Name", reemplaza "New_configuration" con el nombre de tu configuración.

  • En la lengüeta Android, usa el botón "browse"para seleccionar el proyecto y usa la lista "Activity" para seleccionar la "Activity" que será iniciada con la activación del proyecto.

  • En la lengüeta "Emulator", define el tamaño de pantalla y las propiedades de tu red y cualquier otro parámetro adicional para el emulador.

  • En la lengüeta "Common" puedes definir más opciones.

  • Presiona "Apply" para guardar los valores de tu "launch configuration". Luego presiona Run o Close, según corresponda.

  • Ejecución y depurado de una aplicación

    [Título original: Running and Debugging an Application]

    Una vez que has definido el "launch configuration" para tu aplicación, puedes ejecutarla o depurarla. Las siguientes instrucciones explican cómo realizar estas acciones.

  • Desde el menú principal de Eclipse selecciona "Run > Run" o "Run > Debug" , según corresponda.

  • Nota: la "launch configuration" activa es la más reciente "launch configuration" seleccionada en el "Run configuration manager", y por lo tanto no necesariamente corresponde a la aplicación que esté seleccionada en el panel "Eclipse Navigation".

    Para fijar o cambiar la "launch configuration" usa el "Run configuration manager", el cual puedes activar a través de "Run > Open Run Dialog..." o "Run > Open Debug Dialog...."

    La ejecución o depuración de una aplicación realiza los siguientes pasos:

  • Activa el emulador, si es no estuviera activo.

  • Compila el proyecto (si hubo algún cambio desde la última compilación) e instala la aplicación en el emulador.

  • Run : activa la aplicación.

  • Debug : activa la aplicación en modalidad "Wait for debugger", luego abre la "Debug perspective" y anexa el "Eclipse Java debugger" a la aplicación.

  • Desarrollando aplication Android con otros IDEs y herramientas

    [Título original: Developing Android Applications with Other IDEs and Tools]

    Esta sección no la traduciré.

    Depuración una aplicación

    [Título original: Debugging]

    Android provee un amplio conjunto de herramientas que te ayudarán a depurar tus programas:

  • DDMS - Es un programa gráfico que soporta "port forwarding" (esto permite definir "breakpoints" en el código fuente directamente en tu IDE), captura el contenido de la pantalla del emulador, despliega información de "threads" y del "stack" y muchas otras facilidades. Además, es posible ejecutar logcat para recuperar los mensajes de Log de tu aplicación.

  • logcat - Esta herramienta la puedes utilizar para descargar los mensaje de log del sistema. Estos mensajes incluyen información del "stack trace" en el caso que el emulador lance un error, como también los mensajes de Log.

    ...
    I/MemoryDealer( 763): MemoryDealer (this=0x54bda0): Creating 2621440 bytes heap at 0x438db000
    I/Logger( 1858): getView() requesting item number 0
    I/Logger( 1858): getView() requesting item number 1
    I/Logger( 1858): getView() requesting item number 2
    D/ActivityManager( 763): Stopping: HistoryRecord{409dbb20 com.google.android.home.AllApps}
    ...

  • Android Log - Es una clase que provee facilidades para imprimir mensajes de log a hacia un archivo en el emulador. Para leer estos mensaje (en tiempo real) sólo necesitas invocar algunos de los siguientes métodos dentro de tu código: Log.v() (verboso), Log.d() (depurar), Log.i() (información), Log.w() (advertencia) or Log.e (error) . Por ejemplo, Log.i("MiActividad", "MyClass.getView() - La posición : " + posicion). Posteriormente, ejecuta logcat dentro de DDMS.

  • Traceview - Es una aplicación gráfica para leer logs.

  • Eclipse plugin - El "Eclipse Android plugin" incorpora varias de las herramientas para depuración (ADB, DDMS, logcat output y otras funcionalidades).

  • Debug and Test Device Settings - Android expone varias opciones de configuración que permiten recolectar información sobre "CPU usage" y "frame rate".

  • Te recomiendo que también leas la sección "Troubleshooting" para resolver problemas tales como que tu aplicación no es desplegada en el emulador o por qué no se activa.

    Opciones del emulador para depurar y hacer pruebas

    [Título original: Debug and Test Settings on the Device]

    El emulador te permite definir varias opciones que te ayudarán a depurar y testear tus aplicaciones. Para ver las opciones de depuración y pruebas del emulador, selecciona desde la barra de navegación "Dev Tools > Development Settings". Esto abrirá la página "Development Settings".

    En esta página verás las siguientes opciones (entre otras):

  • Debug app : selecciona la aplicación que será depurada. No es necesario que uses está opción para anexar un "debugger", pero al cambiar este valor podrás ver los siguientes efectos: (a) evita que Android lance un error si es que tú haces una pausa o detienes la aplicación en un "breakpoint" por un periodo de tiempo largo cuando estás depurando. (b) te permite seleccionar la opción "Wait for Debugger" para hacer una pausa en la activación de la aplicación hasta que el debugger esté anexado.

  • Wait for debugger : bloquea la aplicación seleccionada hasta que el debugger sea anexado. Esto te permite fijar un breakpoint en onCreate(), el cual es de utilidad al momento de depurar el proceso de inicialización de una "Activity". Cuando seleccionas esta opción, cualquier instancia de la aplicación seleccionada que esté corriendo será destruida. Esta opción sólo puede ser modificada si has seleccionado previamente una aplicación para ser depurada. Para hacer esta misma operación se puede invocar el método waitForDebugger() directamente en tu código.

  • Immediately destroy activities : le comunica al sistema que destruya una "Activity" tan pronto como se detenga (como si Android tuviera que reclamar memoria). Esta opción es de mucha utilidad cuando se requiere probar onFreeze(Bundle) / onCreate(android.os.Bundle) , los cuales de otra forma son difíciles de testear. Esta opción te ayudará a revelar algunos problemas producto que el estado de la aplicación no está siendo guardado correctamente.

  • Show screen updates : muestra por unos instantes un pequeño rectángulo rosado sobre cada área de la pantalla que está siendo pintada. Esta opción es de mucha utilidad para descubrir innecesarios pintados de pantalla.

  • Show CPU usage : despliega "CPU meters" en el borde superior de la pantallaque muestran cuánto de CPU está siendo utilizado. La barra roja muestra el total de CPU usada y la barra verde muestra el tiempo de CPU utilizado en refrescar la pantalla. Nota: no es posible desactivar esta opción una vez que ha sido seleccionada sin reiniciar el emulador.

  • Show screen FPS : despliega el actual "frame rate". Esta opción es de utilidad cuando desarrollar juegos y deseas saber cual es el "frame rate" que posee tu juego. Nota: no es posible desactivar esta opción una vez que ha sido seleccionada sin reiniciar el emulador.

  • Show background : despliegua un patrón de fondo cuando ninguna "activity screens" es visible. Esto generalmente no ocurre, pero puede ocurrir al momento de depurar una aplicación.

  • Estas opciones son guardadas y cargadas por el emulador cada vez que es detenido y reiniciado.

    Consejos de utilidad al depurar una aplicación

    [Título original: Top Debugging Tips]

    ¿Cómo vaciar rápidamente el stack del emulador? : para obtener un vaciado del stack desde el emulador puedes conectarte a través de la "adb shell" y usar "ps" para encontrar el proceso que te interesa y posteriormente ejecutar "kill -3 ", con esto último el "stack trace" aparecerá en el archivo de log.

    ¿Cómo desplegar información de utilidad en la pantalla del emulador?: El emulador (y el dispositivo) puede desplegar información como "CPU usage", para ello activa o desactiva estas opciones en la página "Development Settings".

    ¿Cómo obtener información del estado del sistema desde el emulador (dumpstate)? : Es posible obtener la información del "dumpstate" desde el emulador a través del "Dalvik Debug Monitor Service tool".

    ¿Cómo obtener información del estado de la aplicación desde el emulador (dumpsys)? : Es posible obtener la información del "dumpsys" desde el emulador a través del "Dalvik Debug Monitor Service tool".

    ¿Cómo obtener información de "wireless connectivity"? : Es posible obtener la información de "wireless connectivity" desde el emulador a través del "Dalvik Debug Monitor Service tool". Desde el menú Device selecciona "Dump radio state".

    ¿Cómo registro información de rastreo? : Es posible registrar llamados a métodos y cualquier otro tipo de información de rastreo en una "activity" invocando a android.os.Debug.startMethodTracing().

    ¿Cómo registro "Radio Data"? : Por omisión, información de "radio" no es registrada en el sistema (es un montón de datos). Sin embargo, se puede activar su registro con los siguientes comandos:

    adb shell
    logcat -b radio

    ¿Cómo ejecuto adb? : Android es distribuido con una herramienta llamada "adb", la cual provee facilidades como: sincronización y movimiento de archivos del emulador, forwarding ports, y ejecución de una "UNIX shell" en el emulador.

    ¿Cómo capturo el contenido de la pantalla del emulator? : La herramienta "Dalvik Debug Monitor Server (DDMS)" puede ser utilizada para capturar el contenido de la pantalla del emulador.

    ¿Cuáles son las Helper Classes de Android para depurar? : Android provee las soguientes clases para depurar util.Log y Debug.

    Contrucción e instalación de una aplicación Android

    [Título original: Building and Installing an Android Application]

    Android requiere de algunas herramientas especiales para construir los archivos de recursos y otros componentes de la aplicación. Debido a este razón es que es necesario contar con un entorno de desarrollo especializado para tus aplicaciones.

    El proceso de compilación de Android comprende la compilación de los archivos XML y otros archivos de recursos a los formatos requeridos por la plataforma. Una vez que se compila una aplicación, el resultado es un archivo con extensión ".apk", el cual es un archivo comprimido conteniendo archivos ".dex", archivos de recursos, archivos de datos y otros archivos. Es posible crear manualmente la estructura de un proyecto Android o a partir de algunos archivos fuentes.

    Actualmente, Android no provee soporte para el desarrollo de aplicaciones en código nativo (C/C++).

    El proceso recomendado para desarrollar aplicaciones Android es usar Eclipse junto con el "Android plugin", los cuales proveen soporte para construir, ejecutar y depurar las aplicaciones Android.

    Eliminación de una aplicación Android

    [Título original: Removing an Android Application]

    Para remover una aplicación que tú haz instalado en el emulador es necesario ejecutar"adb" y borrar el archivo ".apk" asociado con la aplicación. Usa la "adb shell" para navegar hasta el directorio "data/app/" y utiliza el comando "rm" para borrar el archivo "your_app.apk".

    Consejos para Eclipse

    [Título original: Eclipse Tips]

    Ejecución de expresiones Java en Eclipse

    [Título original: Executing arbitrary Java expressions in Eclipse]

    Es posible ejecutar código arbitrario en el momento en que Eclise hace una pausa en un "breakpoint". Por ejemplo, tú puedes llamar a métodos static. Si ingresas android.os.Debug.startMethodTracing() esto hará que se active el dmTrace.

    Abre la "code execution window", selecciona Window>Show View>Display desde el menú principal para abrir la "Display window" (un editor de texto). Escribe tu expresión, seleccionar el texto y luego haz clic en el ícono 'J' (o presiona CTRL + SHIFT + D) para ejecutar tu código. El código será ejecutado en el contexto del "thread" seleccioando, el cual debe estar detenido en un "breakpoint" o "single-step point". Si tú suspendes manualmente un "thread", entonces tú tienes un "single-step point", pero esto no funciona si el "thread" está en Object.wait().

    Si tú tienes detenida la aplicación en un "breakpoint", tú puedes seleccionar y ejecutar cualquier pieza de código con sólo presionar CTRL + SHIFT + D.

    Tú puedes seleccionar un bloque de texto dentro de un contexto presionando ALT +SHIFT + UP ARROW o DOWN ARROW.

    Aquí hay unos ejemplos de la respuesta de Eclipse al momento de evaluar expresiones:

    Entrada: zip (java.lang.String)
    Resultado: /work/device/out/linux-x86-debug/android/app/android_sdk.zip

    Entrada: zip.endsWith(".zip")
    Resultado: (boolean) true

    Entrada: zip.endsWith(".jar")
    Resultado: (boolean) false

    También es posible ejecutar código aún cuando no se está depurando usando la ventana "scrapbook". Más información en la documentación de Eclipse ("scrapbook").

    Corriendo DDMS manualmente

    [Título original: Running DDMS Manually]

    A pesar que se recomienda depurar utilizando el "ADT plugin", también es posible hacerlo manualmente ejecutando "DDMS" y configurando Eclipse para depurar conectándose al puerto 8700.

    martes, 20 de noviembre de 2007

    Manos a la obra - Introducción

    Documento original: Getting Started with Android

    Manos a la obra

    [Título original: Getting Started with Android]

    Para de comenzar a desarrollar aplicaciones, por favor lee las siguientes secciones y realiza las instrucciones mencionadas.

  • Instalando el SDK : explica cómo instalar el SDK y el Eclipse plugin. Además, explica cómo utilizar otras herramientas para constuir aplicaciones Android. También se explica cómo ejecutar las aplicaciones de ejemplo.

  • Hola Androide! : explica cómo escribir tu primera aplicación Android, el popular Hello World al estilo Android.

  • Anatomía de una aplicación Android : explica la estructura y arquitectura de una aplicación Android. Esta guía te ayudará a comprender el funcionamiento de las piezas que conforman una aplicación Android.

  • Tutorial: Un editor de anotaciones : aquí encontrarás las instrucciones para construir una aplicación Android de verdad: un editor de anotaciones con el cual podrás crear, editar y borrar tus anotaciones. Esta aplicación cubre muchos de los conceptos básicos a través de ejemplos prácticos.

  • Herramientas de desarrollo : explica qué son y cómo usar las command line tools(*) incluidas con el SDK(*).

  • Ciclo de vida de una aplicación Android : explica los detalles del ciclo de vida de las aplicaciones y de las Activities(*) corriendo dentro de ellas.

  • Otros materiales introductorios

    [Título original: Other Introductory Material]

    Después de leer la secciones anteriores, puedes continuar con la siguiente información que es de mucha utilidad:

    Core Packages

    [Título original: Core Packages]

    Estos son los paquetes básicos del Android SDK y permiten la construcción de cualquier aplicación Android. Estos paquetes están organizados en capas y aquí están ordenados y listados desde el nivel más inferior al superior.

  • android.util : contiene varias clases de utilidad de bajo nivel, tales como utilidades XML, etc.

  • android.os : provee los operating system services(*) básicos, message passing(*) e inter-process communication(*)

  • android.graphics : este es el paquete fundamental para el core rendering(*).

  • android.text , android.text.method, android.text.style y android.text.util : proveen un conjunto de herramientas para procesamiento de texto, soporte para rich text(*), métodos de entrada de datos, etc.

  • android.database : contiene APIs de bajo nivel para trabajar con bases de datos.

  • android.content : provee varios servicios para accesar datos en el dispositivo, tales como aplicaciones instaladas en el dispositivo y sus recursos asociados; content providers para persistent dynamic data(*).

  • android.view : este es el core user-interface framework(*).

  • android.widget : provee los elementos estándard para la interface de usuario (listas, botones, layout managers, etc). Este paquete es construido a partir de android.view.

  • android.app : provee el modelo de aplicación más alto y es implementado usando Activities(*).

  • Otros paquetes de interes

    [Título original: Other Notable Packages]

    Los siguientes paquetes proveen caraterísticas particulares de la Android platform(*), lo que significa que son necesariamente de utilidad para la construcción de aplicaciones.

  • android.provider : contiene las definiciones de varios content providers(*) incluidos en la plataforma.

  • android.telephony : provee APIs para la interacción con el phone stack(*) del dispositivo.

  • android.webkit : incluye varias APIs para trabajar con contenidos basados en web.

  • lunes, 19 de noviembre de 2007

    ¿Qué es Android?

    Documento original: What is Android?

    ¿Qué es Android?

    [Título original: What is Android?]

    Android es un software stack [falta link] para dispositivos móviles, que incluye un sistema operativo, middleware [falta link] y aplicaciones de usuario final. Este lanzamiento preliminar del Android SDK provee las herramientas y las "API"s necesarias para comenzar a desarrollar aplicaciones para la plataforma Android usando el lenguage de programación Java.

    Principales características

    [Título original: Features]

  • Provee el Android Application Framework [falta link] que facilita la reutilización y reemplazo de componentes.

  • Incluye la Dalvik, la cual es una Virtual Machine optimizada para dispositivos móviles.

  • Disponibilidad de un browser integrado con la plataforma, el cual está basado en WebKit.

  • Capacidades gráficas mejoradas a través de librerías gráficas 2D optimizadas y gráficos 3D basados en la especificación "OpenGL ES 1.0" (la aceleración del hardware es opcional).

  • Incluye SQLite para el almacenamiento estructurado de datos.

  • Soporte para multi media y sus formatos más comunes: audio, video, and fotografías (MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, GIF).

  • Soporte para telefonía GSM (dependiente del hardware).

  • Bluetooth, EDGE, 3G y WiFi (dependiente del hardware).

  • "API"s de acceso a recursos de cámaras, GPS, brújula y acelerómetro (dependiente del hardware).

  • Un entorno de desarrollo que incluye un emulador de dispositivo, herramientas para depurar, perfilador de memoria y rendimiento, y un "plugin" para Eclipse.

  • Arquitectura de Android

    [Título original: Android Architecture]

    El siguiente diagrama muestra los principales componentes del sistema operativo de Android. Cada una de las secciones es descrita en detalle a continuación del gráfico.

    Figura:http://code.google.com/android/images/system-architecture.jpg

    Aplicaciones

    [Título original: Applications]

    Android será distribuido junto a un grupo de aplicaciones que incluyen: cliente de email, programas de SMS, calendario, mapas, browser, contactos y otras interesantes aplicaciones. En adelante, utilizaré el término Core Applications [falta link] para referirme a este conjunto de applicaciones. Todas las Core Applications [falta link] fueron escritas utilizando el lenguaje de programación Java.

    Estructura de las aplicaciones

    [Título original: Application Framework]

    Los desarrolladores tienen completo acceso a las "API"s que fueron usadas para construir las Core Applications [falta link]. La Android Application Architecture [falta link] está diseñada para simplificar la reutilización de componentes, esto gracias a que cualquier aplicación puede publicar sus capacidades y entonces otras aplicaciones pueden hacer uso de aquellas capacidades (todo sujeto a restricciones de seguridad impuestas por Android). Este mecanismo permite que cualquier componente pueda ser reemplazado a voluntad del usuario.

    Subyacente a todas las aplicaciones existe un conjunto de servicios y sistemas que incluyen:

  • Un conjunto rico y extensible de vistas (View) que pueden ser usados para construir una aplicación, incluyendo listas, matrices, casillas para entrada de texto, botones e incluso un browser.

  • Varios proveedores de contenidos (Content Provider) que proveen a las aplicaciones la capacidad para accesar datos desde otras aplicaciones (tales como Contacts) o compartir sus propios datos.

  • Un administrador de recurso (Resource Manager) que provee acceso a recursos tales como información regionalizada, gráficos y archivos de diseño.

  • Un administrador de notificaciones (Notification Manager) que provee a las aplicaciones la capacidad para desplegar, en la barra de estado mensajes de alerta personalizados.

  • Un administrador de actividades (Activity Manager) que administra el ciclo de vida de las aplicaciones y proveen un mecanismo de navegación entre las aplicaciones (Navigation Backstack [falta link]).

  • Para más detalles y un vistazo rápido a una aplicación, ver Desarrollo de un sencillo editor de texto.

    Librerías

    [Título original: Libraries]

    Android incluye un conjunto de librerías escritas en C/C++, las cuales son usadas por varios componentes del sistema Android. Estas capacidades son expuestas a los desarrolladores a través del Android Application Framework [falta link]. Las principales librerías son descritas a continuación:

  • System C library: es una implementación "BSD-derived" de la "standard C system library (libc)", que ha sido mejorada para ser incrustada en dispositivos basados en Linux.

  • Media Libraries: estas librerías permiten la reproducción y grabación de/en los formatos de audio, video y fotografía más populares. Incluye: MPEG4, H.264, MP3, AAC, AMR, JPG, and PNG. Estas librerías están basadas en "PacketVideo's OpenCORE".

  • Surface Manager: administra el acceso los subsistemas de pantalla y utilización de gráficos 2D y 3D desde múltiples aplicaciones.

  • LibWebCore: es un "web browser" que potencia tanto el "Android Browser" como las Web View.

  • SGL: el motor gráfico 2D subyacente al sistema.

  • 3D libraries: es una implementación basada en las "OpenGL ES 1.0 API"s. Estas librerías pueden usar tanto el hardware 3D de aceleración (si está disponible) o el "3D rasterizer" que es incluido en Android.

  • FreeType: es el "font rasterizer" para mapas de bits y vectores.

  • SQLite: es un poderoso y liviano motor de bases de datos relacionales que está disponible para todas las aplicaciones.

  • Entorno de ejecución de Android

    [Título original: Android Runtime]

    Android incluye un conjunto de librerías que proveen muchas de las funcionalidades disponible en las librerías del lenguaje de programación Java.

    Cada aplicación Android es ejecutada dentro de su propio proceso, dentro de su propia instancia de una Dalvik Virtual Machine. Dalvik ha sido diseñada de tal forma que el dispositivo puede correr múltiples Virtual Machines de manera eficiente. La Dalvik Virtual Machine ejecuta archivos en formato Dalvik Executable (.dex), los cuales han sido optimizados para optener el menor "memory footprint". La Virtual Machine es "register-based" y ejecuta archivos de clases compilados en un compilador Java que ha sido modificado para crear archivos en formato .dex con ayuda de la herramienta dx.

    La Dalvik Virtual Machine depende del Linux Kernel para todas las subyacentes funcionalidades, tales como "threading" and "low-level memory management".

    Kernel de Linux

    [Título original: Linux Kernel]

    Android depende de Linux version 2.6 para los "core system services" tales como securidad, administración de memoria, administración de procesos, "network stack", y "driver model". El Linux Kernel también actúa como una capa de abstación entre el hardware y el resto del software stack [falta link].

    viernes, 16 de noviembre de 2007

    Bienvenido a Android

    Bienvenido a Android!

    [Título original: Welcome to Android!]

    Documento original: Welcome to Android!

    La plataforma Android es un software stack [falta link] para dispositivos móviles que incluye un sistema operativo, middleware [falta link] y algunas aplicaciones para el usuario del dispositivo. Los desarrolladores pueden crear aplicaciones para esta plataforma usando el "Android SDK". Las aplicaciones son escritas utilizando el lenguaje de programación Java y posteriormente compiladas para ser ejecutadas en Dalvik, que es una Virtual Machine [falta link] diseñada para correr sobre un Linux kernel [falta link].

    Si tú quieres aprender cómo desarrollar aplicaciones para Android, tú estás en el lugar correcto. Este sitio web provee una variedad de documentación que te ayudará en el aprendizaje de Android y el desarrollo de aplicaciones móviles para la plataforma.

    El "Android SDK" está disponible en estos momentos en un estado de "early look". Esta versión incluye proyectos de ejemplo con código fuente, herramientas de desarrollo, un emulador y por supuesto todas las librerías que tú vas a necesitar para construir una aplicación Android.

    Desde la siguiente página Descarga de Android SDK puedes descargar el "Android SDK"

    Para aprender sobre la plataforma Android, Google recomienda leer la "Documentación de Androide" en el siguiente orden.

    ¿Qué es Android?

    Un vistazo a la plataforma Android.

    Manos a la obra

    Todo lo necesario para desarrollar tu primera aplicación: Hello World

    Desarrollando aplicaciones Android

    Los fundamentos de las aplicaciones Android.

    Caja de herramientas [falta link]

    Información más exhaustiva sobre diferentes tópicos.

    Información de referencia. [falta link]

    Todo el material de referencia de Android.

    Ejemplos de código. [falta link]

    Código fuente de varios projectos Android.

    Respuesta a las preguntas más frecuentes. [falta link]

    Problemas y sus soluciones.

    Lanzamiento de Android

    El 5 de noviembre, la Open Handset Alliance anunció el lanzamiento de Android (Androide); el cual es una plataforma completa de software para dispositivos móviles. Esta nueva plataforma incluye: un sistema operativo basado en unix, middleware y aplicaciones para el usuario final.

    Desde el inicio Androide fue diseñado con la idea de proporcionar completo acceso a todas las capacidades de cualquier dispositivos móvil, para que asi los desarrolladores tengan la capacidad de crear aplicaciones sofisticadas.

    La creación de aplicaciones para esta nueva plataforma se hace utilizando Android SDK, el cual está disponible desde el 12 de noviembre.

    lunes, 5 de noviembre de 2007

    Términos técnicos

    La siguiente lista corresponde a los términos técnicos que he decidido no traducir para permitir que posteriormente los utilices para realizar búsquedas en Google.
    • SDK tools directory : directorio de herramientas Android SDK.
    • SDK directory : directorio raíz del Android SDK.
    • Android Debug Bridge (adb) :
    • Android platform : plataforma Androide.
    • Activities :
    • core user-interface framework :
    • persistent dynamic data :
    • rich text :
    • core rendering :
    • inter-process communication :
    • operating system services :
    • command line tools :
    • software stack : es una referencia genérica a un conjunto de programas que en su conjunto constituyen un sistema completo.
    • operating system : sistema operativo
    • middleware : software que realiza las funciones de conversión o transformación de un sistema a otro.
    • SDK : (Software Development Kit) conjunto de herramientas de desarrollo de software.
    • Android SDK : conjunto de herramientas de software para desarrollar aplicaciones Android.
    • Java : lenguaje de programación creado por James Gosling.
    • Dalvik : Java virtual machine para aplicaciones Android.
    • virtual machine : máquina virtual.
    • Linux kernel : núcleo de Linux

    jueves, 1 de noviembre de 2007

    Referencias

    A continuación se encuentran las referencias que he encontrado en Internet relacionadas con Android:

    Android - An Open Handset Alliance Project
    http://www.blogger.com/code.google.com/android
    Este es el sitio oficial de Android para desarrolladores.

    Android Development Community
    http://www.anddev.org/
    Este es un sitio con tutoriales y además puedes encontrar soluciones a problemas.

    DEVPHONE BLOG
    http://www.blogger.com/devphone.com
    Este es un blog que es actualizado con frecuencia con las últimas noticias relacionadas con Google Android y tecnologías relacionadas.

    The significance of Google’s Android
    http://visionmobile.com/blog/2007/11/the-significance-of-googles-android/
    Esta nota de blog hace un buen análisis sobre la estrategia comercial de Google con Android.

    DroidDraw Tutorial

    http://www.droiddraw.org/tutorial.html
    Este página provee de un applet que ayuda a diseñar las pantallas de una aplicación Android.

    Google Maps with My Location (beta)
    http://www.google.com/gmm/mylocation.html?hl=en
    Este artículo describe la aplicación "My Location"

    Show me the code!
    http://davanum.wordpress.com/
    Este blog publica algunos ejemplo de interesantes.