Androide

Declaración - Disclaimer

2008-12-17T18:18:00.000-08:00

Declaración
Google, The Open Handset Alliance y Sun Microsystems, Inc. no endosan este blog ni autorizan el desarrollo de mis proyectos personales. De hecho, este blog es el resultado de mis intereses personales y no ha sido endosado ni autorizado por ninguna entidad comercial.

Disclaimer
Neither Google,The Open Handset Alliance nor Sun Microsystems, Inc. have endorsed this page or authorized the development of my personal projects. In fact, this blog is the result of my personal interests and it has not been endorsed or authorized by any commercial entity.

En este Blog voy a publicar mi experiencia desarrollando software para Android® platform utilizando Java®. Además, publicaré mis notas personales sobre algunos documentos de la documentación de Android®.

In this Blog I'm going to publish my experience developing software for Android® platform using Java®. Also, I'll publish my personal notes about some documents of Android's documentation.

Sobre mis notas personales

2008-12-16T09:44:00.000-08:00

Algunas cosas sobre mis notas personales:

Continuar con la traduccion cuando tengamos en el mercado telefonos con Android instalado.

TIP: Sensor Simulator

2008-03-06T09:15:00.000-08:00

En la siguiente página encontrarás un simulador excelente para generar datos de ubicación geográfica y de movimiento para tu emulador.

http://code.google.com/p/openintents/

Desarrollando aplicaciones - Almacenamiento, recuperación y exposición de datos

2008-01-15T12:02:00.001-08:00

Documento original: Storing, Retrieving and Exposing Data

Almacenamiento, recuperación y exposición de datos

[Título original: Storing, Retrieving and Exposing Data]

Un típico sistema operativo de escritorio provee un sistema de archivos común que cualquier aplicación puede usar para almacenar y leer archivos que pueden ser leídos por otras aplicaciones (quizá definiendo algunos controles de acceso). Android usa un sistema diferente: en Android, todas los datos de aplicaciones (incluyendo archivos) son privados a esa aplicación. Sin embargo, Android también provee una forma standard para que una aplicación exponga sus datos privados a otra aplicación. Esta sección describe todas las formas en las que una aplicación puede almacenar y recuperar datos, exponer sus datos a otras aplicaciones y también la forma en la cual tú puedes solicitar datos desde otras aplicaciones que exponen sus datos.

Android provee los siguiente mecanismos para almacenar y recuperar datos:

Preferencias : Es un mecanismo liviano que permite almacenar y recuperar datos primitivos en la forma de pares clave/valor. Este mecanismo es típicamente usado para almacenar las preferencias de la aplicación.

Archivos : Tú puedes almacenar tus archivos en el dispositivo o en un medio de almacenamiento removible. Por omisión, las otras aplicaciones no tienen acceso a estos archivos.

Base de datos : Las APIs de Android contienen soporte para SQLite. Tu aplicación puede crear y usar base de datos SQLite privadas. Cada base de datos es privada al paquete que la crea.

Proveedores de contenidos : Un proveedor de contenidos es un componente opcional de una aplicación y expone el acceso de lectura/escritura a los datos privados de la aplicación, sujeto a las restricciones que tú quieras imponer. Los proveedores de contenidos implementan una sintaxis estándard para solicitar datos y un mecanismo de acceso estándard para devolver los datos. Android provee algunos proveedores de contenidos para tipos de datos estándard, tales como contactos personales.

Redes : No te olvides que también puedes usar la red para almacenar y recuperar datos.

Desarrollando aplicaciones - Bloques de construcción de Android

2007-12-30T18:29:00.000-08:00

Documento original: Android Building Blocks

Bloques de construcción de Android

[Título original: Android Building Blocks]

Puedes ver una aplicación Android como una colección de componentes de varios tipos. Estos componentes en su mayoría tienen un bajo nivel de acloplamiento entre ellos, a tal grado que te permiten describirlos de manera muy precisa como una federación de componentes más que un aplicación como un todo.

Por lo general, todos estos componentes corren en el mismo proceso del sistema. Es posible (y muy común) crear múltiples "thread"s dentro de tal proceso, y además es posible crear procesos hijos completamente separados del proceso padre, si es que tú lo llegaras a necesitar. Estos últimos casos son poco comunes ya que Android trata en lo posible de hacer los procesos lo más transparente en tu código.

Estas son las partes más importantes de las APIs de Android:

AndroidManifest.xml : El archivo "AndroidManifest.xml" es el archivo de control que le dice al sistema qué es lo que debe hacer con los componentes de más alto nivel que tú haz creado (específicamente "Actividad", "Servicio", "Receptor de Intentos" y "Proveedor de Contenidos" descritos a continuación). Debido a esto, este archivo es considerado el "pegamento" que indica qué "Intent" serán recibidos por tus "Activity.

Actividad : Una "Activity" es, fundamentalmente, un objeto que tiene un ciclo de vida. Una "Activity" es un trozo de código que hace algún trabajo. Si fuera necesario, este trabajo puede incluir el despliegue de una UI al usuario. Sin embargo, lo anterior no es necesario y algunas "Activity" nunca despliegan una UI. Típicamente, tú designarás una de las "Activity" de tu aplicación como el punto de inicio de tu aplicación.

Vista : Una "View" es un objeto que sabe cómo dibujarse asimismo en la pantalla. Las interfaces de usuario de Android están conforman un árbol de "View". Si tú quieres realizar algún tipo de técnica gráfica especial entonces deberás crear una "View" (este es el caso en el cual tú quisieras crear un juego o construir un nuevo tipo de interface de usuario)

Intento : Un "Intent" es un simple mensaje que representa "la intención" de hacer algo. Por ejemplo, si tu aplicación quiere abrir una página web, debe expresar su "Intento" para ver la URI a través de la creación de una instancia de "Intent" y luego entregársela al sistema. Posteriormente, el sistema ubicará una pieza de código que sepa cómo manipular aquel "Intento" y la ejecuta (en este caso un browser). Los "Intent" también pueden ser usados para difundir eventos interesantes a través de todo el sistema (tales como notificaciones).

Servicio : Un "Service" es un cuerpo de código que se ejecuta en segundo plano. Se ejecuta dentro de su propio proceso o en el contexto del proceso de otra aplicación, dependiendo de sus necesidades. Otros componentes se "atan" a un "Servicio" e invocan sus métodos a través de "llamados remotos de procedimientos (RPC)". Un ejemplo de un "Service" es un reproductos de música. En este caso, el usuario podría usar una UI para seleccionar la música y posteriormente cerrar la UI, pero la música deberá continuar sonando. Esto se logra usando un "Servicio" que continuará la reproducción de la música.

Notificación : Una notificación es un pequeño ícono que aparece en la barra de estado. Los usuarios pueden interactuar con este ícono para recibir información. Las notificaciones más conocidas son los mensajes SMS, correo de voz; pero las aplicaciones pueden crear sus propias notificaciones. Las notificaciones son el mecanismo preferido para alertar al usuario que algo requiere de su atención.

Proveedor de Contenidos : Un "ContentProvider" es un almacen de datos que provee acceso a datos en el dispositivo. Un ejemplo clásico es el "ContentProvider" que es usado para tomar datos desde la lista de contactos. Tu aplicación puede utilizar datos que otras aplicaciones han expuesto vía un "ContentProvider". Tú también puede definir tus propios "ContentProvider" para así exponer tus propios datos.

Desarrollando aplicaciones - Escuchando notificaciones de la UI

2007-12-21T19:29:00.000-08:00

Documento original: Listening for UI Notifications

Escuchando notificaciones de la UI

[Título original: Listening for UI Notifications]

Algunas notificaciones de la UI son automáticamente expuestas y llamadas por Android. Por ejemplo, una "Activity" sobreescribe los métodos "onKeyDown" y "onKeyUp" y "TextView" expone "onFocusChanged(boolean, int)". Sin embargo, algunos métodos "callbacks", tales como clic de botones no son expuestos de manera nativa y deben ser registrados manualmente como se muestra a continuación.

public class SendResult extends Activity
{
    /**
     * Initialization of the Screen after it is first created.  Must at least
     * call setContentView() to
     * describe what is to be displayed in the screen.
     */
    protected void onCreate(Bundle savedValues)
    {
        ...

        // Listen for button clicks.
        Button button = (Button)findViewById(R.id.corky);
        button.setOnClickListener(mCorkyListener);
    }

    // Create an anonymous class to act as a button click listener.
    private OnClickListener mCorkyListener = new OnClickListener()
    {
        public void onClick(View v)
        {
            // To send a result, simply call setResult() before your
            // activity is finished.
            setResult(RESULT_OK, "Corky!");
            finish();
        }
    };

Desarrollando aplicaciones - Enganchando un elemento de la pantalla

2007-12-21T19:14:00.000-08:00

Documento original: Hooking into a Screen Element

Enganchando un elemento de la pantalla

[Título original: Hooking into a Screen Element]

Tú puedes obtener una referencia a un elemento de la pantalla llamando al método "Activity.findViewById()". Posteriormente, puedes usar esta referencia para modificar o recuperar valores expuestos por ese elemento.

TextView msgTextView = (TextView)findViewById(R.id.msg);
msgTextView.setText(R.string.push_me);

Desarrollando aplicaciones - Definiendo tu pantalla con XML

2007-12-21T19:03:00.000-08:00

Documento original: Designing Your Screen in XML

Definiendo tu pantalla con XML

[Título original: Designing Your Screen in XML]

Debido a que el diseño de una pantalla a través de código puede resultar muy engorroso, Android soporta una sintaxis XML para diseñar pantallas. Android define un gran número de elementos especialmente hechos para la plataforma, cada uno de ellos representando una subclase específica de Android View. Tú puedes diseñar tu pantalla de la misma forma en la que tú crear archivos HTML, es decir, como una serie de etiquetas anidades y guardadas en un archivo XML dentro del directorio "res/layout/" de tu aplicación. Para aprender qué elementos son expuestos y el formato del archivo XML lee el documento "Available Resource Types" y en especial la sección "Layout Resources". Cada etiqueta describe un único elemento "android.view.View", pero este elemento puede ser un simple elemento visual o un elemento de esquema que contiene una colección de objetos hijos (una pantalla o una porción de ella). Cuando Android compila tu aplicación, compila cada archivo en un "android.view.View" recurso que tú puedes cargar en tu código llamando al método "setContentView(R.layout.layout_file_name)" dentro de la implementación que hagas del método "onCreate()" de tu "Activity".

Cada archivo XML esta formado por etiquetas que corresponden a clases GUI de Android. Estas etiquetas tienen atributos que en su mayoría corresponden a métodos en esa clase (por ejemplo, la etiqueta "EditText" tiene un atributo de texto que corresponde al método "setText()" de la clase "EditText").

NOTA: No existe una correspondencia exacta entre nombres de clase/métodos y nombres de etiquetas/atributos. Son parecidos por no 1:1

NOTA: Android tiende a dibujar los elementos en el orden en el cual aparecen en el documento XML. Por lo tanto, if hay elementos que se sobreponen, el último en el archivo será probablemente el que aparezca sobre cualquier otro que esté previamente declarado en su mismo espacio.

Cada archivo XML es compilado dentro de un árbol que tiene como raíz un objeto "View" o "ViewGroup", por lo tanto debe tener una sola etiqueta raíz.

Los atributos llamados "layout_algo" modifican el miembro "algo" del objeto "LayoutParams". El documento "Layout Resources" también describe cómo aprender la sintaxis para algunas propiedades específicas de "LayoutParams".

Los siguientes valores son soportados para dimensiones (descritos en "TypedValue").

dip (pixeles independientes del dispositivo)

sp (pixeles escalados - mejor opción para tamaño de texto)

pt (puntos)

in (pulgadas)

mm (milimetros)

px (pixeles)

Ejemplo: android:layout_width="25px"

Para más información sobre estas dimensiones, ver "Dimension Values".

El siguiente archivo XML crea la pantalla que es mostrada debajo de él. El texto en el borde superior fue dibujado llamando al método "setTitle()" de la clase "Activity". Los atributos que se refieren elementos relativos ("layout_toLeft") hacen uso del ID del elemento usando la sintaxis de recursos relativos ("@id/id_number").

<?xml version="1.0" encoding="utf-8"?>
<!-- Demonstrates using a relative layout to create a form -->
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android
 android:layout_width="fill_parent" 
 android:layout_height="wrap_content"
 android:background="@drawable/blue"
 android:padding="10px">

    <TextView id="@+id/label" 
  android:layout_width="fill_parent" 
  android:layout_height="wrap_content" 
  android:text="Type here:"/>

    <EditText id="@+id/entry" 
  android:layout_width="fill_parent" 
  android:layout_height="wrap_content" 
  android:background="@android:drawable/editbox_background"
  android:layout_below="@id/label"/>
  
    <Button id="@+id/ok" 
  android:layout_width="wrap_content" 
  android:layout_height="wrap_content" 
  android:layout_below="@id/entry"
  android:layout_alignParentRight="true"
  android:layout_marginLeft="10px"
  android:text="OK" />

    <Button android:layout_width="wrap_content" 
  android:layout_height="wrap_content"
  android:layout_toLeft="@id/ok"
  android:layout_alignTop="@id/ok"
  android:text="Cancel" />
</RelativeLayout>

Figura:http://code.google.com/android/images/designing_ui_layout_example.png

Cargando los recursos XML

[Título original: Loading the XML Resource]

Cargar y compilar los recursos del esquema de tu pantalla es muy sencillo y es hecho en un simple llamado dentro método "onCreate()", tal como se muestra a continuación:

protected void onCreate(Bundle savedValues)
{
   // Be sure to call the super class.
   super.onCreate(savedValues);

   // Load the compiled layout resource into the window's
   // default ViewGroup.
   // The source file is res/layout/hello_activity.xml
    setContentView(R.layout.hello_activity);
  
   // Retrieve any important stored values.
   restoreValues(savedValues);
}

Desarrollando aplicaciones - Trabajando con AdapterView

2007-12-21T17:42:00.000-08:00

Documento original: Working with AdapterViews (Binding to Data)

Trabajando con AdapterViews (asociando datos a vistas)

[Título original: Working with AdapterViews (Binding to Data) ]

Como se mencionón, algunos grupos de vistas tienen UI. Estos objetos tipicamente son subclases de "AdapterView". Algunos ejemplos son "Gallery" (una "widget" con un selección de imágenes) y "ListView" (una lista de vistas. Estos objetos hacen dos tareas en común:

Llenar el esquema con datos.

Manipular las selecciones del usuario.

Llenando el esquema con datos

[Título original: Filling the layout with data]

Esto es típicamente hecho a través de la asociación de la clase con un "Adapter" que toma los datos de alguna parte: una lista que el código suministra o el resultado de una consulta a una base de datos del dispositivo.

// Get a Spinner and bind it to an ArrayAdapter that 
// references a String array.
private String[] fruit = {"apples", "oranges", "lemons"}
Spinner s1 = (Spinner)findViewById(R.id.fruitlist);
s1.setAdapter(new ArrayAdapter<String>(this, R.layout.spinner_1, mStrings));

// Load a Spinner and bind it to a data query.
private String[] cols={android.provider.Contacts.PeopleColumns.NAME};
private Cursor cur = managedQuery(android.provider.Contacts.People.CONTENT_URI, cols, null, null);
s2.setAdapter(new CursorAdapter(cur, this));

Manipular las selecciones del usuario

[Título original: Handling user selections]

Esto es hecho al asignar al miembro "AdapterView.OnItemClickListener" de la clase un objeto escuchador de eventos y capturar los cambios que el usuario hace en su selección.

// Create a message handling object as an anonymous class.
private OnItemClickListener mMessageClickedHandler = new OnItemClickListener() {
    public void onItemClick(AdapterView parent, View v, int position, long id)
    {
        // Display a messagebox.
        showAlert("You've got an event", "Clicked me!", "ok", false);
    }
};

// Now hook into our object and set its onItemClickListener member
// to our class handler object.
mHistoryView = (ListView)findViewById(R.id.history);
mHistoryView.setOnItemClickListener(mMessageClickedHandler);

Desarrollando aplicaciones - Objetos comunes de esquema

2007-12-18T02:10:00.000-08:00

Documento original: Common Layout Objects

Objetos comunes de esquema

[Título original: Common Layout Objects]

Los siguientes son los grupos de vistas más comunes que tú vas a usar en tus aplicaciones. Esta sección te entregará la información básica sobre cada uno de ellos. Para estudiar en más profundidad cada uno de ellos, puedes seleccionar el link que cada elemento provee.

FrameLayout

[Título original: FrameLayout]

Un FrameLayout es el objeto de esquema más sencillo. Está expresamente diseñado como un espacio en blanco reservado en la pantalla que posteriormente podrás llenar con un único objeto, por ejemplo una fotografía cuya imagen será intercambiada. Todos los elementos hijos son posicionados en la parte superior izquierda de la pantalla. No es posible establecer una posición determinada para un elemento hijo de FrameLayout. Elementos hijos que posteriormente se agreguen serán simplemente dibujados sobre elementos que previamente hayan sido dibujados, lo que bloqueará su visión total o parcialmente (a menos que los nuevos elementos sean transparentes).

LinearLayout

[Título original: LinearLayout]

Un LinearLayout alinea todos sus elementos hijos en una única dirección: vertical u horizontal, de acuerdo a qué propiedad tú definiste para LinearLayout. Todos los hijos son ubicados uno al lado del otro, por lo tanto una lista vertical sólo tendrá un hijo por fila sin importar cuan ancha sea la fila. De manera similar, un lista horizontal sólo tendrá un fila de alto (la altura del hijo más alto más el espacio de relleno definido, ie, "padding"). El LinearLayout respeta los márgenes entre hijos y también su gravedad (alineamiento del hijo hacia la derecha, centro o izquierda).

El LinearLayout también soporta la asignación de peso a hijos de manera individual. Este peso, permite a los hijos expandirse para llenar cualquier espacio restante de la pantalla. Esto previene que una lista de pequeños objetos sea confinada hacia uno de los extremos de una pantalla grande y por el contrario se expanda para llenar todo el espacio disponible. El peso que los hios tienen especificado es utilizado para distribuir cualquier espacio restante en la misma proporción de su peso declarado. El valor por omisión del peso de un hijo es cero. Por lo ejemplo, si hay tres casillas de texto, y dos de ellas declaran un un peso de 1, dos de ellas se expandirán de con la misma proporción para llenar el espacio restante, y la tercera no crecerá ninguna cantidad adicional.

Las imágenes de los formularios mostrados a continuación representan un LinearLayout con un conjunto de elementos: un botón, algunas etiquetas de texto y algunas casillas de texto. Ambos tienen definido valores para relleno de contorno, para así mantener un contorno que proporciona un agradable distribución. Las casillas de texto tienen sus anchos fijados al valor "FILL_PARENT", otros elementos lo tienen fijado a "WRAP_CONTENT". Por omisión, el valor de la gravedad es fijado a izquierda ("left"). El formulario de la izquierda no tiene valores de peso fijados, por lo tanto todos sus hijos tienen el valor cero (valor por omisión). El formulario de la derecha tiene fijado el valor del peso de la casilla de texto de comentarios a "1". Si el peso de la casilla de texto para el nombre hubiese sido fijado a "1", las casillas de texto para el nombre y los comentarios hubiesen tenido la misma altura.

CONSEJO: Para crear un esquema de tamaño proporcionado en la pantalla, crea un objeto contenedor que sea "fill_parent", luego asigna la altura y ancho de los hijos a cero y finalmente asigna los valores de peso relativos a cada hijo dependiendo de la proporción que cada uno de ellos debe ocupar en la pantalla

Figura:http://code.google.com/android/images/linearlayout.png

Dentro de un LinearLayout, los items son alineados por la posición de sus líneas base del texto (la primera línea del primer elemento,i.e., la más alta o más a la izquierda es la línea considerada como referencia). Esto es así para evitar que las personas al llenar un formulario tengan que buscar un elemento en elementos vecinos. Esta característica puede ser desactivada agregando android:baselineAligned="false" en tu esquema XML.

TableLayout

[Título original: TableLayout]

Un "TableLayout" posiciona sus hijos dentro de filas y columnas. Un "TableLayout" está compuesto por un número de objetos "TableRow", cada uno de ellos definiendo una fila (más adelante explicaremos que también es posible tener otros elementos hijos). Los contenedores "TableLayout" no despliegan contornos para sus filas, columnas y celdas. Cada fila tiene cero o mas celdas, y cada celda puede contener un objeto ""View"". Una tabla puede tener tantas columnas como lo tenga la fila con más celdas. Una tabla puede tener celdas vacías. Las celdas no pueden extenderse a otras columnas, como lo hace HTML. La siguiente imagen muestra un esquema de tabla en la cual los border invisibles son mostrados con líneas punteadas.

Figura:http://code.google.com/android/images/table_layout.png

Las columnas pueden estar ocultas, ser marcadas para estirarse y ocupar todo el espacio disponible, o marcadas para comprimirse hasta que la tabla se ajuste al tamaño de la pantalla. Encontrarás más información en el siguiente link: TableLayout

AbsoluteLayout

[Título original: AbsoluteLayout]

El "AbsoluteLayout" permite que los elementos hijos especifiquen con precisión las coordenadas "x" e "y" en la cual deben ser desplegados. La posición (0,0) corresponde a la esquina superior izquierda, y sus valores se incrementan en la medida que tu avanzan hacia abajo y a la derecha. Márgenes no son soportados y el solapamiento de elementos está permitido (pero no es recomendado). La recomendación general es no usar "AbsoluteLayout" a menos que tengas una muy buena razón para usarlo, porque este esquema es muy rígido y no funciona bien en todos los dispositivos.

RelativeLayout

[Título original: ]

El esquema "RelativeLayout" permite que sus elementos hijos espeficiquen su posición relativa entre ellos(indicando un ID) o con su padre. De esta forma, puedes alinear dos elementos por su contorno derecho, o poner uno debajo de otros, o centrarlo en la pantalla. Los elementos son dibujados en un order dado, de tal forma que si el primer elemento está centrado en la pantalla los otros elementos se alinearán considerando su posición relativa al centro de la pantalla. Si estás usando XML para describir el esquema de pantalla (como se describirá más adelante), un elemento referenciado debe ser declarado antes de hacer referencia a él.

Aquí hay un ejemplo de un esquema relativo destacando los elementos invisibles y visibles. El objeto raíz del esquema de la pantalla es un "RelativeLayout".

Figura:http://code.google.com/android/images/designing_ui_relative_layout.png

Este diagrama muestra los nombres de las clases de los elementos en la pantalla, seguido por una lista de las propiedades de cada uno de ellos. Algunas de estas propiedades son soportadas directamente por los elementos y otras son soportadas por su miembro "LayoutParams" (una subclase de "RelativeLayout" en todos los elementos de esta pantalla, debido a que todos los elementos son hijos del objeto padre "RelativeLayout"). Los parámetros de "RelativeLayout" son: "width", "height", "below", "alignTop", "toLeft", "padding" y "marginLeft". Se debe observar que algunos de estos parámetros soportan valores relativos a otros hijos, de ahí viene el nombre "RelativeLayout". Esto incluye las propiedades "toLeft", "alignTop" y "below", las cuales referencian al objeto de la izquierda, de arriva y de abajo; respectivamente.

Resumen de los grupos de vistas más importantes

[Título original: Summary of Important View Groups]

Todos estos objetos contienen elementos UI. Algunos proveen elementos UI visibles y otros sólo controlan el esquema de sus elementos hijos.

AbsoluteLayout : Permite que espeficiques la ubicación de los objetos hijos relativa al padre usando medidas exactas (por ejemplo, pixeles).

FrameLayout : Este esquema actúa como un marco que despliega sólo un objeto.

Gallery : Es un esquema para desplegar imágenes (tomadas de una lista) y tiene la capacidad para desplazar su contenido de manera horizontal.

GridView : Es un esquema cuadriculado de "n" filas por "m" columnas. Además, tiene capacidades para desplazar el contenido.

LinearLayout : Es un esquema que organiza sus elementos hijos dentro de una sólo fila, la cual puede ser horizontal o vertical.Crea una barra de desplazamiento si el tamaño de la cuadrícula excede el tamaño de la pantalla.

ListView : Es un esquema que despliega una lista dentro de una sola columna y tiene capacidad de desplazamiento del contenido.

PopupList : Es un esquema que despliega el contenido de una lista con bordes, de manera independiente y emergente

RelativeLayout : Este esquema permite que espeficiquemos la ubicación de sus elementos hijos relativa entre ellos (ejemplo: un elemento "A" al lado del elemento "B") o con el padre (por ejemplo: alineación con el borde superior del padre).

ScrollView : Es un esquema que despliega elementos en un columna vertical con capacidad de desplazamiento de contenido.

Spinner : Este esquema despliega un sólo elemento a la vez (tomado de una lista asociada) dentro de una casilla de texto de una fila. Este esquema es diferente de un esquema con una fila con capacidad para desplegar el contenido horizontalmente o verticalmente.

SurfaceView : Este esquema provee acceso directo a una superficie dedicada al dibujado. Puede contener elementos de vistas superpuestos sobre la superficie, pero está diseñado para aplicaciones que necesitan dibujar pixeles en vez de usar "widgets".

TabHost : Este esquema provee una lengüeta de selección que monitorea clics y permite que la aplicación cambie de pantalla en el momento en que la lengüeta es cliqueada.

TableLayout : Es un esquema tabular con un número arbitario de filas y columnas, cada una de las celdas contiene un "widget" de tu elección. Las filas ajustan su tamaño para ajustar la columna más grande. El contorno de las celdas no son visibles.

ViewFlipper : Es un esquema de despliega un elemento a la vez dentro de una casilla de texto de una fila. Puede ser configurado para intercambiar elementos a cierto intervalo de tiempo, como si fuera una presentación de diapositivas.

ViewSwitcher : Similar a ViewFlipper

Desarrollando aplicaciones - Jerarquía de los elementos de la pantalla

2007-12-17T16:19:00.000-08:00

Documento original: Hierarchy of Screen Elements

Jerarquía de los elementos de la pantalla

[Título original: Hierarchy of Screen Elements]

La unidad funcional básica de una aplicación Android es la "Activity", el cual es un objeto de la clase "android.app.Activity". Una "Activity" puede hacer muchas cosas, pero por si misma ella no tiene presencia en la pantalla. Para otorgarle a tu "Activity" presencia en la pantalla y diseñar su interface de usuario, tienes que trabajar con "View" y "ViewGroup", las cuales son las unidades básicas de expresión de la interface de usuario en la plataforma Android.

Vistas

[Título original: Views]

Una vista es un objeto cuya clase base es "android.view.View". Es una estructura de datos cuyas propiedades almacenan el esquema y contenido para una determinada área rectangular de la pantalla. Un objeto "View" manipula el dimensionamiento y esquema, realiza el pintado, controla los cambios de foco, desplazamiento de áreas y teclado/gestos para el área de la pantalla que representa.

La clase "View" sirve de base para los "widgets", que son un conjunto de subclases implementadas completamente que dibujan elementos interactivos en la pantalla. Los "widgets" manipulan sus propios dimensionamientos y pintado, de tal forma que tú puedes usarlos para construir tus propias UI mucho más rápido. La lista de "widgets" disponibles incluye: "Text", "EditText", "InputMethod", "MovementMethod", "Button", "RadioButton", "Checkbox" y "ScrollView".

Grupos de vistas

[Título original: Viewgroups]

Un "ViewGroup" es un objeto de la clase "android.view.Viewgroup". Como su nombre lo indica, un grupo de vistas es un tipo especial de objeto "View", cuya función es contener y administrar un conjunto subordinado de "View" y otros "ViewGroup". Los "ViewGroup" nos permiten agregar una estructura a nuestras "UI" y así construir elementos de pantalla mucho más complejos que puedan ser manipulados como un único elemento.

La clase "ViewGroup" sirve de clase base para crear esquemas, los cuales son un conjunto de subclases implementadas completamente que provee de los tipos más comunes de elementos de pantalla. Los esquemas nos entregan una forma de construir una estructura para un conjunto de "View".

Un árbol jeráquico de UI

[Título original: A Tree-Structured UI]

En la plataforma Android, tú puedes definir una "Activity" con UI usando un árbol de "View" y nodos de "ViewGroup", tal como lo muestra el diagrama que está a continuación. El árbol puede ser simple o complejo según tus necesidades, y puede ser construido usando un conjunto predefinido de "widgets" y elementos de Android o tipos de "View" con características especiales que tí hayas creado.

Figura:http://code.google.com/android/images/viewgroup.png

Para enlazar el árbol a la pantalla y así efectuar su visualización, nuestra actividad "Activity" llama a sus método "setContentView()" y pasa la referencia una referencia al objeto del nodo raíz. Una vez que el sistema Android tiene una referencia al objeto del nodo raíz, éste puede trabajar directamente con el nodo para invalidarlo, medirlo y dibujar el árbol. Cuando tú "Activity" se activa y recibe el foco, el sistema notifica a tu "Activity" y le solicita al nodo raíz que mida y dibuje el árbol. Entonces, el nodo raíz le solicita a sus nodos hijos que se dibujen así mismo, a su vez cada nodo de grupo de vistas del árbol es responsable de dibujar sus nodos hijos directos.

Como se mencionó previamente, cada "ViewGroup" tiene la responsabilidad de medir su espacio disponible, posicionar sus hijos dentro del esquema y llamar al método "Draw()" por cada uno de sus hijos para que se dibujen asimismos. Los hijos podrían solicitar una ubicación y tamaño específico al padre, pero es el objeto padre quien tiene la última decisión con respecto a que tan grande cada hijo puede ser.

LayoutParams: ¿Cómo especificar la posición y tamaño de un hijo?

[Título original: LayoutParams: How a Child Specifies Its Position and Size]

Cada "ViewGroup" usa una clase anidada que hereda de "ViewGroup.LayoutParams". Esta subclase contiene tipos de propiedades que definen el tamaño y posición de un hijo en propiedades que son apropiadas para esa clase de "ViewGroup".

Figura:http://code.google.com/android/images/layoutparams.png

NOTA: Cada subclase de "LayoutParams" tiene su propia sintaxis para asignar sus valores. Cada elemento hijo debe definir un "LayoutParams" que sea apropiado para su padre, aunque éste último podría definir un "LayoutParams" diferente para sus hijos.

Todos los incluyen ancho y alto. Muchos incluso tienen márgenes y contorno. Tú puedes indicar un ancho y alto determinados, pero probablemente no lo harás de manera frecuente. Lo más probable es que dejarás que tu vista se auto dimensione al tamaño de sus contenidos o tan grande como el objeto que lo contiene lo permita.

Desarrollando aplicaciones - Implementando la interface de usuario

2007-12-17T16:05:00.000-08:00

Documento original: Implementing a User Interface

Implementando la interface de usuario

[Título original: Implementing a User Interface]

Esta sección describe las bases de cómo implementar la interface de usuario de una pantalla Android. Se describirán los elementos básicos para construir una pantalla, cómo definirla basada en un esquema XML y cómo cargarla en tu código. Además de varias otras tareas que tú vas a necesitar realizar en el diseño y desarrollo de la interface de usuario.

Estos serán los tópicos abordados en esta sección:

Jerarquía de los elementos de la pantalla

Objetos comunes de esquema

Trabajando con AdapterViews (asociando datos a vistas)

Diseñando tu pantalla con XML

Enganchando un elemento de la pantalla

Escuchando notificaciones de la UI

Aplicando un tema a tu aplicación.

Elementos de UI y glosario de conceptos.

Desarrollando aplicaciones - Introducción

2007-12-17T14:11:00.000-08:00

Documento original: Developing Android Applications

Desarrollando aplicaciones Android

[Título original: Developing Android Applications]

Tú puedes desarrollar una aplicación Android con el mismas herramientas de alta calidad que tú usas para desarrollar cualquier otra aplicación Java. Las "Android core libraries" proveen las funcionalidades necesarias para construir impresionantes y poderosas aplicaciones para dispositivos móviles, y las herramientas de desarrollo de Android para hacerla correr, depurar y testear muy rápidamente.

Esta sección explica todos los detalles asociados con el desarrollo de aplicaciones Android y explica los delineamientos de la filosofía detrás del sistema y luego describe en detalle cada uno de los subsistemas claves. Después de leer esta sección tú tendrás el conocimiento y confidencia para comenzar a escribir cualquier aplicación Android que tengas en tu mente.

Antes de leer esta sección tú deberías haber leído toda la sección "Manos a la obra", la cual te entrega la información necesaria para rápidamente impregnarte del "Android SDK" y mostrarte cómo construir tu primera aplicación y algunos tutoriales en los que aprenderás más sobre las aplicaciones Android. Esta sección está basada en la información entregada en "Manos a la obra".

Aquí está el detalles de los contenidos que encontrarás en esta sección:

Implementando una "UI": esta sección explicará cómo construir e interactuar con las interfaces de usuario de las aplicaciones Android. Después de leer esta página tú vas a tener un sólido entendimiento de cómo los esquemas de pantalla son construidos, cómo ellos funcionan en tiempo de ejecución y cómo puedes cambiar su aspecto visual para mejorar su apariencia.

Bloques de construcción: esta sección contiene una descripción detallada de los componentes de Android. Cubre todos los pormenores de los componentes que fueron descritos en "Anatomía de una aplicación Android" y mucho más. Esta sección profundiza en los detalles de cada uno de los componentes claves de Andriod (Intent, Activity, View y eventos).

Almacenamiento y recuperación de datos: esta sección explica cómo leer y escribir datos desde/hacia varios mecanismos de almacenamiento provistos por Android y hacia servicios de red. Existen varias formas de leer y escribir datos desde una aplicación y cada uno de ellos está orientado a satisfaces diferentes necesidades. En esta sección encontrarás la descripción de todos ellos y la orientación necesaria para saber cual de ellos seleccionar en determinada situación.

Modelo de seguridad: esta sección explica cómo obtener acceso a los recursos y características del sistema de seguridad y cómo declarar los permisos necesarios para controlar el acceso a nuestras propias características de seguridad, es decir, el control de permisos que permiten que dada una aplicación sea pueda tener acceso a piezas de funcionalidad provistas por otra aplicación (por ejemplo, qué aplicación puede marcar un teléfono). Esta sección describe la forma en la cual los permisos funcionan y cómo solicitar los permisos que tú has definido.

Recursos e i18n: esta sección entrega información detallada del sistema de administración de los recursos y aplicaciones, incluyendo cómo es utilizado para propósitos de internalización y regionalización. Los "recursos" son el material que una aplicación necesita en tiempo de ejecución (tales como imágenes, cadenas de caracteres, archivos XML, etcétera). Esta sección describirá cómo Android resuelve cual recurso cargar desde una selección de ellos, y cómo crear y usar estos recursos.

¿CÓMO HACER? - Reaccionar a un mensajes SMS

2007-12-17T10:48:00.000-08:00

Documento original: Recognize/React on incoming SMS

En esta nota les explicaré el código documentado de una aplicación Android que reacciona a la recepción de la llegada de un mensaje SMS.

SMSReceiver.java

01 package com.northvortex.sms;
02 
03 import android.app.NotificationManager; 
04 import android.content.Context; 
05 import android.content.Intent; 
06 import android.content.IntentReceiver; 
07 import android.os.Bundle; 
08 import android.provider.Telephony; 
09 import android.telephony.gsm.SmsMessage; 
10 import android.util.Log; 
11 
12 /**
13 * android.content.IntentReceiver
14 * Base class for code that will receive intents sent by broadcastIntent()...
15 * http://code.google.com/android/reference/android/content/IntentReceiver.html
16 *
17 */
18 public class SMSReceiver 
19 extends IntentReceiver 
20 { 
21 // Etiqueta usada para la bitacora. 
22 private static final String TAG_LOG = "SMSReceiver"; 
23 
24 // Un numero aleatorio utilizado por la notificacion. 
25 private static final int ID_NOTIFICACION = 0x1221; 
26 
27 // Esta es la action que sera gatillada cuando un mensaje SMS es recibido. 
28 // Usamos la "Default Package-Visibility".
29 private static final String ACCION = "android.provider.Telephony.SMS_RECEIVED";
30 
31 /**
32 * Este metodo es gatillado cuando se recibe el Intent que esperabamos.
33 */
34 @Override 
35 public void onReceiveIntent(Context parContext, Intent parIntent) 
36 { 
37 // As we want to display a Notification, we the NotificationManager. 
38 NotificationManager elNotificador = (NotificationManager)parContext.getSystemService(Context.NOTIFICATION_SERVICE);
39 
40 // Verifico que la accion recibida es ''
41 if (parIntent.getAction().equals(ACCION) == true) 
42 { 
43 // if(message starts with SMStretcher recognize BYTE) 
44 StringBuilder elContenido = new StringBuilder(); 
45 
46 // La informacion del mensaje SMS vienen dentro del paquete de datos extras del Intent. 
47 Bundle losDatosExtras = parIntent.getExtras(); 
48 if (losDatosExtras != null) 
49 { 
50 // Recuperamos los mensajes que vienen dentro del Intent. 
51 SmsMessage[] losMensajesSMS = Telephony.Sms.Intents.getMessagesFromIntent(parIntent); 
52 
53 // Creo el mensaje que mostrare en la pantalla. 
54 for (SmsMessage unMensaje : losMensajesSMS)
55 { 
56 elContenido.append("Mensajes SMS\n");
57 elContenido.append("enviado por:");
58 // Numero de quien envio el mensaje. 
59 elContenido.append(unMensaje.getDisplayOriginatingAddress() + "\n"); 
60 elContenido.append("Mensaje:\n"); 
61 // Contenido del mensaje.
62 elContenido.append(unMensaje.getDisplayMessageBody()); 
63 } 
64 } 
65 
66 // Registramos en la bitacora el evento.
67 Log.i(TAG_LOG, "onReceiveIntent: " + elContenido); 
68 
69 // Mostramos el mensaje utilizando el administrador de notificaciones 
70 elNotificador.notifyWithText(ID_NOTIFICACION, elContenido.toString(), 
71 NotificationManager.LENGTH_LONG, null); 
72 
73 // Consumimos este Intent, de esa forma ninguna otra aplicacion lo notara. 
74 this.abortBroadcast();
75 
76 // Ahora intentamos gatillar una actividad adicional. 
77 Intent elIntento = new Intent(parContext, SMSActivity.class); 
78 elIntento.setLaunchFlags(Intent.NEW_TASK_LAUNCH); 
79 parContext.startActivity(elIntento); 
80 } 
81 return;
82 } 
83 }

SMSActivity.java

01 package com.northvortex.sms;
02 
03 import android.app.Activity;
04 import android.os.Bundle;
05 
06 /**
07  * 
08  * Este es la clase que gatillare despues de mostrar el contenido del mensaje.
09  *
10  */
11 public class SMSActivity
12    extends Activity
13 {
14    /**
15     * Esta clase es llamada la  vez que la actividad es creada.
16     */ 
17    @Override 
18    public void onCreate(Bundle parICicle) 
19    { 
20       super.onCreate(parICicle); 
21       
22       setContentView(R.layout.main);
23       
24       return;
25    }
26 }

AndroidManifest.xml

01 <?xml version="1.0" encoding="utf-8"?> 
02 <manifest xmlns:android="http://schemas.android.com/apk/res/android" 
03     package="com.northvortex.sms"> 
04     <uses-permission id="android.permission.RECEIVE_SMS" /> 
05     <application android:icon="@drawable/icon"> 
06         <!-- The Main Activity that gets started by the IntentReceiver listed below -->
07         <activity class=".SMSActivity" android:label="@string/app_name"> 
08             <intent-filter> 
09                 <action android:value="android.intent.action.MAIN" /> 
10                 <category android:value="android.intent.category.LAUNCHER" /> 
11             </intent-filter> 
12         </activity>
13         <!-- This class will react on the SMS show a notification and start the Main-App afterwards --> 
14         <receiver class=".SMSReceiver"> 
15             <intent-filter> 
16                 <action android:value="android.provider.Telephony.SMS_RECEIVED" /> 
17             </intent-filter> 
18         </receiver>     
19     </application> 
20 </manifest>

main.xml

01 <?xml version="1.0" encoding="utf-8"?>
02 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
03     android:orientation="vertical"
04     android:layout_width="fill_parent"
05     android:layout_height="fill_parent"
06     >
07 <TextView  
08     android:layout_width="fill_parent" 
09     android:layout_height="wrap_content" 
10     android:text="SMS Activity"
11     />
12 </LinearLayout>

strings.xml

1 <?xml version="1.0" encoding="utf-8"?>
2 <resources>
3     <string name="app_name">SMS Receptor</string>
4 </resources>

¿CÓMO HACER? - Simular envío de SMS al emulador

2007-12-17T08:31:00.000-08:00

Documento original: Simulating incoming Phone Calls / SMS in ECLIPSE

En esta nota les explicaré como simular el envío de un mensaje SMS al emulador dentro de Eclipse.

NOTA: Para este ejemplo necesitas haber instalado la versión "android_sdk_windows_m3-rc37a" del "Android SDK" o una versión posterior.

A continuación está las instrucciones paso a paso:

PASO #1 - Habilita la perspectiva "DDMS".

Para esto presiona el botón "Open Perspective", tal como lo muestra la siguiente figura:

Eso hará que se abra el siguiente menú:

Esto hará que se habrá la ventan "Open Perspective". Selecciona "DDMS" y luego presiona el botón "OK". Como lo muestra la siguiente figura:

Esto hará que se habilite la perspectiva "DDMS". Como lo muestra la siguiente figura:

NOTA: En WINDOWS, después de habilitar esta perspectiva tendrás que reiniciar Eclipse ya que se perderán momentaneamente los tabuladores de la ventan "Run".

PASO #2 - Envío del SMS

Para esto ejecuta alguno de tus proyectos, de esa forma la perspectiva "DDMS" se activará.

Una vez que tu aplicación esté corriendo, selecciona la perspectiva "DDMS". Dentro de esta perspectiva verás la siguiente el marco "Emulator Control". Usa estos controles para enviar tu mensaje SMS, tal como lo muestra la siguiente figura:

Usando aapt

2007-12-15T12:48:00.000-08:00

Documento original : Using aapt

Usando "aapt" (Using aapt)

Las siglas "aapt" corresponde a "Android Asset Packaging Tool" y la puedes encontrar en el directorio "tools/" del "SDK". Esta herramienta te permite examinar, crear y actualizar archivos compatibles con "ZIP" (zip, jar, apk). También puede convertir (compilar) archivos de recursos a material binario.

Aunque probablemente tú no utilices directamente "aapt", algunos "scripts" y "plugins" para IDEs pueden utilizar esta herramienta para empaquetar los archivos de una aplicación Android en un archivo ".apk".

Para más detalles de cómo usar este comando, abre una consola de comandos y navega al directorio "tools/" y ejecuta el comando:

Linux:

./aapt

Windows:

aapt.exe

Manos a la obra - Herramientas para el desarrollo

2007-12-14T20:36:00.000-08:00

Documento original: Development Tools

Herramientas de desarrollo

[Título original: Development Tools]

El "Android SDK" incluye una variedad de herramientas especialmente diseñadas para ayudarte en el desarrollo de aplicaciones móbiles sobre la plataforma Android. La herramienta más importante es el "Android Emulator" y las "Android Development Tools" plugin para Eclipse", pero el SDK también incluye un surtido de otras herramientas para depuración, empaquetado e instalación de aplicaciones en el dispositivo o emulador.

Emulador Android

[Título original: Android Emulator ]

El "Android Emulator" es un dispositivo virtual que corren en tu computador. El emulador tiene como finalidad ayudarte a diseñar, depurar y testear tus aplicaciones en un ambiente similar al que existe en un dispositivo real.

Android Development Tools Plugin para Eclipse IDE

[Título original: Android Development Tools Plugin for the Eclipse IDE]

El "ADT plugin" agrega poderosas extensiones al ambiente integrado de Eclipse haciendo que la creación y depuración de tus aplicaciones Android sea fácil y rápida. Si tú desarrollas estás usando Eclipse, el "ADT plugin" te da un increíble estímulo para el desarrollo de las aplicaciones Android. A continuación algunas de sus características:

Provee acceso a otras herramientas de desarrollo de Android desde el entorno de Eclipse IDE. Por ejemplo, "ADT" te permite el acceso a muchas de las capacidades de la herramienta "DDMS", tales como tomar fotografías de la pantalla, administrar el redireccionamiento de puertos, fijar puntos de quiebre y examinar la información "thread" y procesos directamente dentro de Eclipse.

Provee un asistente para la creación de proyectos Android, el cual te ayuda a crear rapidamente todos los directorios y archivos necesarios para crear una nueva aplicación Android.

Automatiza y simplifica el proceso de construcción de una aplicación.

Provee un editor de código Android que te ayuda a escribir XML válido para el archivo "AndroidManifest.xml".

Para mayor información sobre "ADT plugin", incluyendo las instrucciones de instalación, lee "Instalando el SDK". Para estudiar un simple ejemplo, lee "Hola Androide!".

Dalvik Debug Monitor Service - ddms

[Título original: Dalvik Debug Monitor Service - ddms]

La "Dalvik Debug Monitor Service" es un herramienta integrada con la "Dalvik Virtual Machine", y nos permite administrar los procesos que corren en una instancia de emulador/dispositivo y nos asiste en la depuración de ellos. Podemos usar esta herramienta para terminar la ejecución de un proceso, seleccionar un determinado proceso para depurar, generar reportes a partir de información de bitácoras, examinar el "heap" y la información de "thread, tomar fotografías de la pantalla del emulador/dispositivo y mucho más.

Android Debug Bridge - adb

[Título original: Android Debug Bridge - adb]

La herramienta "adb" nos permite instalar nuestras aplicaciones (archivos ".apk") en una instancia de emulador/dispositivo y accesar una instancia de emulador/dispositivo usando comandos de línea. También podemos utilizarlo para enlazar un depurador estándar al código de una aplicación que esté corriendo en una instancia de emulador/dispositivo.

Herramienta Android Asset Packaging - aapt

[Título original: Android Asset Packaging Tool - aapt]

La herramienta "aapt" te permite crear archivos ".apk", los cuales contienen las imágenes binarias de tu código y recursos de tus aplicaciones.

Android Interface Description Language - aidl

[Título original: Android Interface Description Language - aidl]

Te permite generar código para una interface de interproceso, tal como la que un servicio podría utilizar.

sqlite3

[Título original: sqlite3]

Esta herramienta ha sido incluida para comodidad de los desarrolladores. Nos provee acceso a los archivos de datos "SQLite" creados y usados por las aplicaciones Android.

Traceview

[Título original: Traceview]

Esta herramienta produce una vista gráfica del análisis de información contenida en bitácoras que puede ser generada desde una aplicación Android.

mksdcard

[Título original: mksdcard]

Esta herramientas nos ayuda a crear una imagen de disco que podemos usar con el emulador, para simular la presencia de una tarjeta de almacenamiento externa (tal como una tarjeta "SD").

dx

[Título original: dx]

La herramienta "dx" convierte los archivos de "bytecode" estándar (".class") en archivos "Android bytecode" (".dex").

activityCreator

[Título original: activityCreator]

Es un "script" que genera archivos "Ant build" que puedes utilizar para compilar tus aplicaciones Android. Si tú estas desarrollando con Eclipse y "ADT plugin", no necesitas utilizar "activityCreator".

Manos a la obra - Tutorial - Depurando tu aplicación

2007-12-14T14:35:00.000-08:00

Documento original: Tutorial: Extra Credit

En este ejercicio, vas a usar el depurador para mirar de cerca el trabajo que hicimiento en el tutorial anterior Manos a la obra - Tutorial - Ejercicio #3

Aprenderás a:

Fijar un punto de quiebre para examinar la ejecución de la aplicación.
Cómo correr una aplicación en modo de depuración.

Paso 1

Usando el proyecto "Notepadv3", colocaremos un punto de quiebre al comienzo del código fuente de los métodos "onCreate()", "onPause()", "onFreeze()" y "onResume()" de la clase "NoteEdit".

NOTE: Para crear un punto de quiere (breakpoint) en Eclipse basta que abrás el menú emergente (clic con botón derecho) del borde gris del lado izquierdo de la ventana de edición, directamente sobre la línea en la cual quieres poner el punto de quiebre. Cuando aparesca el menú emergente, selecciones la opción "Toggle Breakpoint" y luego un punto azul debería aparecer sobre el borde gris.

Paso 2

Ahora inicializaremos la aplicación en mode de depuración:

Abre el menú emergente del proyecto "Notepadv3", expande la opción "Debug As" y selecciona "Android Application".
El emulador de Android debería desplegar por un instante el mensaje "waiting for debugger to connect" y entonces iniciar la ejecución de la aplicación.
Si llegará a quedarse pegado en la pantalla de "waiting...", termina la ejecución del emulador y también Ecliose. Luego, desde una terminal de comandos ejecuta el comando "adb kill-server" y entonces reinicia Eclipse y volver a intentar los pasos anteriores.

Paso 3

Al momento de crear una nueva nota deberías ver que la aplicación se detiene en uno de los puntos de quiebre que hemos definido.

Paso 4

Presiona el botón "Resume" para que la ejecución de la aplicación continúe (el botón "Resume" es aquel rectángulo amarillo con un triángulo verde a su derecha. Está ubicado en el lado izquierdo de la barra de herramientas de Eclipse).

Paso 5

Experimenta un poco presionando los botones "Confirm" y "Back". Prueba presional el botón "Home" y observa los eventos del ciclo de vida que son generados como resultado de esta operación.

El "Android Eclipse plugin" no sólo ofrece un excelente soporte para depuración de tus aplicaciones, sino que además un poderoso soporte para perfilar (profiling). Si tu aplicación está corriendo muy lento, esta característica del plugin puede ayudarte a encontrar los cuello de botella y corregirlos.

Android Debug Bridge

2007-12-13T14:43:00.000-08:00

Android Debug Bridge

[Título original: Android Debug Bridge]

Documento original: Android Debug Bridge

El "Android Debug Bridge" ("adb") es un herramienta muy versátil que te permite controlar el estado de un dispositivo o un emulador.

Algunas de las funciones cosas que puedes hacer con "adb" son:

Actualización de código del dispositivo o emulador, tales como aplicaciones o actualizaciones del sistema Android.

Ejecutar comandos de "shell" en el dispositivo.

Administrar el direccionamiento de puertos de un emulator o dispositivo.

Copiar archivos hacia o desde un emulador o dispositivo.

Las siguientes secciones describen algunos de los comandos más comunes de usar con "adb".

Introducción

[Título original: Overview]

La herramienta "adb" es un programa cliente/servidor que incluye los siguientes componentes:

Un cliente que corre en tu máquina de desarrollo. Tú puedes invocar este cliente desde una consola de comandos ejecutando el comando "adb". Otras herramientas de Android, tales como el "ADT plugin" y "DDMS", crean sus propios clientes "adb".

Un servidor que se ejecuta como un proceso en segundo plano en tu máquina de desarrollo. Este servidor administra la comunicación entre el cliente y el "adb daemon" que corre dentro del emulador o dispositivo.

Un "daemon" que se ejecuta como un proceso de segundo plano en cada instancia de un emulador o dispositivo.

Cuando tú inicias un cliente "adb", lo primero que hace este cliente es verificar si hay un proceso servidor "adb" que esté corriendo. Si no lo hay, entonces el cliente inicia un proceso servidor "adb". Cuando el proceso servidor "adb" comienza a ejecutarse, asocia su servicio al puerto TCP número 5037 y se queda escuchando la llegada de comandos enviados desde los clientes "adb". Todos los clientes "adb" utilizan el puerto 5037 para comunicarse con el servidor "adb".

Posteriormente, el servidor "adb" establece conexiones hacia todas las instancias de emuladores/dispositivos que estén corriendo. El servidor "adb" localiza a las instancias de emuladores/dispositivos examinando todos los puertos con número impar dentro del rango de 5555 a 5585, el cual es el rango utilizado por los emuladores/dispositivos. Cuando el servidor "adb" encuentra un "adb daemon", estable de inmediato una conexión con él. Algo importante de saber es que cada emulador/dispositivo adquiere un par de puertos consecutivos:

un puerto de número par para recibir solicitudes de conexión de consola.

un número de puerto impar para las conexiones con el servidor "adb".

Por ejemplo:

Emulador #1:
consola: 5554
adb daemon: 5555

Emulador #2:
consola: 5556
adb daemon: 5557

Como se muestra en el ejemplo anterior, la instancia del emulador que está conectada con el servidor "adb" a través del puerto 5555, es la misma instancia cuya consola está escuchando en el puerto 5554.

Una vez que el servidor "adb" ha establecido las conexiones con las instancias de los emuladores/dispositivos, podemos comenzar a usar comandos "adb" para controlar y tener acceso a esas instancias. Debido a que el servidor "adb" administra las conexiones hacia todas las instancias de emuladores/dispositivos y maneja los comandos enviados por múltiples clientes "adb", podemos controlar cualquier instancia de un emulador/dispositivo desde cualquier cliente "adb" o "script".

Las secciones que leerás a continuación describen los comandos que tú puedes utilizar para utilizar las capacidades de "adb" y administrar el estado de un emulador/dispositivo. Ten en consideración que si tu estás desarrollando aplicaciones Android en Eclipse y has instalado el "ADT plugin", no es necesario que invoques "adb" desde una consola de comandos. El "ADT plugin" provee una integración transparente con "adb" dentro del entorno de desarrollo de Eclipse. Sin embargo, siempre puedes utilizar "adb" directamente.

Utilizando comandos "adb"

[Título original: Issuing adb Commands]

Puedes invocar cualquier comando "adb" desde una consola de comandos en tu máquina de desarrollo o desde un "script". La sintáxis de los comandos es:

adb [-d {<ID><serialNumber>}] <command>

Cuando tú When you despachar un comando, el programa invoca un cliente "adb", el cual no está asociado a ninguna instancia de emulador en particular, por lo tanto si hay múltiples emuladores/dispositivos corriendo tienes que utilizar el parámetro "-d" para indicar la instancia hacia la cual el comando debe ser dirigido. Para mayor información sobre cómo usar este parámetro lee "Dirigiendo comando hacia un emulador/dispositivo específico".

Averiguando qué emuladores/dispositivos están conectados

[Título original: Querying for Emulator/Device Instances]

Antes de comenzar a ejecutar comando "adb", es de mucha utilidad saber qué instancias de emuladores/dispositivos están conectadas al servidor "adb". Para obtener un listado de las instancias de emuladores/dispositivos que están corriendo y el estado de cada uno de ellos, podemos usar el siguiente comando:

En respuesta, "adb" imprime la siguiente información de estado para cada una de las instancias:

Idetificador : es un identificador asignado por "adb" a cada instancia que es inicializada ("adb" asigna el identificador "1" a la primera instancia inicializada, y así sucesivamente).

Número de serie : es una cadena de caracteres creada por "adb" para identificar de manera única a cada instancia de emulaor/dispositivo asociado a un puerto específico.

Estado : es el estado de la conexión de la instancia. Hay tres estados que son soportados: (A) device : indica que la instancia está conectada al servidor "adb". (B) offline : indica que la instancia no está conectada o no responde. (C) bootloader : indica que el "bootloader" está corriendo.

Bloqueo: Indica si la instancia está bloqueada. Un valor de "0" significa que está no está bloqueada.

La salida de cada instancia es desplegada con el siguiente formato:

[ID] [serialNumber] [state] [lock]

Este es un ejemplo de cómo podría ser la salida de este comando:

$ adb devices
List of devices attached 
1 emulator-tcp-5555 device 0
2 emulator-tcp-5557 device 0
3 emulator-tcp-5559 device 0

Si no hubiera ningún emulador/dispositivo corriendo, "adb" imprimiría "no device".

Dirigiendo comando hacia un emulador/dispositivo específico

[Título original: Directing Commands to a Specific Emulator/Device Instance]

Si múltiples instancias de emuladores/dispositivos están corriendo, necesitas indicar a cual de ellas vas a dirigir tus comandos. Para hacer esto, usa el parámetro "-d" en cada uno de los comandos. La sintáxis para este parámetros es:

Como se mostró, indicas la instancia objetivo utilizando el número de serie que "adb" asignó a cada una de ellas. Puedes utilizar el comando "devices" para obtener el número serial de las instancias de emuladores/dispositivos que estén corriendo.

A continuación hay dos ejemplos:

adb -d 2 install helloWorld.apk

adb -d emulator-tcp-5557 install helloWorld.apk

Ten en consideración que si envias un comando sin indicar el emulador/dispositivo objetivo, entonces "adb" por omisión enviará al comando a la primera instancia asociada al puerto "5555" (si es que hubiera una instancia conectada a ese puerto).

Instalación de una aplicación

[Título original: Installing an Application]

Tú puedes utilizar "adb" para copiar una aplicación desde tu computador de desarrollo e instalar la en una instancia de emulador/dispositivo. Para hacer esto, usa el comando "install". Al usar este comando tú tienes que indicar la ubicación del archivo ".apk" que deseas instalar:

adb install path_to_apk

Para mayor información sobre cómo crear un archivo ".apk" que pueda ser instalado en una instancia de emulador/dispositivo lee "Usando aapt".

NOTA: Si tú estás usando Eclipse e instalaste "ADT plugin", no necesitas usar "adb" o "aapt" para instalar tus aplicaciones en el emulador/dispositivo. El "ADT plugin" se encarga del empaquetado e instalación de las aplicación.

Redireccionamiento de puerto

[Título original: Port Forwarding]

Podemos usar el comando "forward" para fijar arbitrariamente el redireccionamiento de un puerto, y así direccionar los requerimientos de un puerto hacia uno diferente en una instancia de un emulador/dispositivo. A continuación hay un ejemplo de cómo fijar el redireccionamiento del puerto 6100 en el host al puerto 7100 en el emulador/dispositivo:

adb forward tcp:6100 tcp:7100

También podemos usar "adb" para redireccionar un puerto hacia un dominio de socket abstracto de UNIX. El siguiente ejemplo ilustra este caso:

adb forward tcp:5556 local:logd

Copiando archivos desde o hacia una instancia de emulador/dispositivo

[Título original: Copying Files to or from an Emulator/Device Instance]

Podemos usar los comandos "pull" y "push" para copiar archivos hacia y desde una instancia de emulador/dispositivo. A diferencia del comando "install", el cual sólo copia un archivo ".apk" a una ubicación específica, los comandos "pull" y "push" nos permiten copiar archivos y directorios arbitrarios a cualquier ubicación dentro de la instancia del emulador/dispositivo.

Para copiar un archivo o directorio (recursivamente) desde el emulador/dispositivo usa:

adb pull <remote> <local>

Para copiar un archivo o directorio (recursivamente) hacia el emulador/dispositivo usa:

adb push <local> <remote>

En los comandos, "local" y "remote" se refieren a ubicaciones de archivos/directorios en tu máquina de desarrollo ("local") y en la instancia del emulador/dispositivo ("remote").

A continuación se muestra un ejemplo:

adb push foo.txt /tmp/foo.txt

Listado de comandos "adb"

[Título original: Listing of adb Commands]

A continuación se listan los comandos soportados por "adb" y se explica su significado y uso:

Categoría: Opcional

[Título original: Category: Option]

Comando: -d {<ID><serialNumber>}
Descripción: Permite que indiquemos una instancia de emulador/dispositivo a la cual deseamos enviar un comando. 
La instancia del emulador/dispositivo es referenciada utilizando su identificador o número de serie.
Comentario: Si no se indica este parámetro, "adb" dirigirá el comando a la instancia por omisión 
(es decir, la instancia que está asociada al puerto "5555".

Categoría: General

[Título original: Category: General]

Comando: devices
Descripción: Imprime un listado de todos los emuladores/dispositivos que están conectados.
Comentario: Para más detalles lee "Averiguando qué emuladores/dispositivos están conectados".

Comando: help 
Descripción: Imprime un listado con los comandos soportados por "adb"
Comentario:

Comando: version
Descripción: Imprime la versión de "adb"
Comentario:

Categoría: Depuración

[Título original: Category: Debug]

Comando: logcat [<option>] [<filter-specs>]
Descripción: Imprime el log de datos en la pantalla.
Comentario:

Comando: bugreport
Descripción: Imprime información de "dumpsys", "dumpstate" y "logcat" en la pantalla, con el propósito de crear un reporte de defectos.
Comentario:

Categoría: Datos

[Título original: Category: Data]

Comando: install <path-to-apk>
Descripción: Instala una aplicación Android en el emulador/dispositivo (debe indicarse la ubicación completa del archivo ".apk".
Comentario:

Comando: pull <remote> <local>
Descripción: Copia un determinado archivo desde una instancia de emulador/dispositivo hacia tu máquina de desarrollo.
Comentario:

Comando: push <local> <remote>
Descripción: Copia un determinado archivo desde tu máquina de desarrollo hacia una instancia del emulador/dispositivo.
Comentario:

Categoría: Puertos y redes

[Título original: Category: Ports and Networking]

Comando: forward <local> <remote>
Descripción: Direcciona conexiones de socket desde un específico puerto local a un específico puerto remoto en una instancia de emulador/dispositivo.
Comentario: La especificación de un puerto puede utilizar los siguientes esquemas:

tcp:<portnum> 
local:<UNIX domain socket name> 
dev:<character device name>

Comando: ppp <tty> [parm]...
Descripción: Ejecuta "PPP" sobre "USB".
<tty> es el "tty" para el "PPP stream". Por ejemplo, "dev:/dev/omap_csmi_ttyl.
[parm]... es cero o más opciones "PPP/PPPD", tales como "defaultroute", "local", "notty", etc.
NOTA: No debería iniciar automáticamente una conexión "PDP".
Comentario:

Categoría: Comandos de línea

[Título original: Category: Scripting]

Comando: get-serialno
Descripción: Imprime el identificador de la instancia.
Comentario:

Comando: get-state
Descripción: Imprime el estado "adb" de una instancia de emulador/dispositivo.
Comentario:

Comando: wait-for-bootloader
Descripción: Bloquea la ejecución hasta que el "bootloader" esté en línea, esto es hasta que el estado de la instancia es "bootloader".
Comentario:

Comando: wait-for-device
Descripción: Bloquea la ejecución hasta que el dispositivo esté en línea, esto es hasta que el estado de la instancia es "device".
Comentario: Este comando puede ser anexado a otros comandos "adb". 
En este caso, "adb" va a esperar hasta que la instancia del emulador/dispositivo esté conectada antes de enviar el otro comando. 
Por ejemplo: adb wait-for-device <command>.

Categoría: Servidor

[Título original: Category: Server]

Comando: start-server
Descripción: Verifica si el proceso del servidor "adb" está corriendo y lo activa si no lo estuviera.
Comentario:

Comando: kill-server
Descripción: Termina el proceso del servidor "adb".
Comentario:

Categoría: Intérprete de comandos

[Título original: Category: Shell]

Comando: shell
Descripción: Inicia una "shell" remota en la instancia del emulador/dispositivo objetivo.
Comentario: Lee "Enviando comandos de shell".

Comando: shell [<shellCommand>]
Descripción: Envia un comando de "shell" a la instancia del emulador/dispositivo objetivo y luego termina la "shell" remota.
Comentario: Lee "Enviando comandos de shell".

Enviando comandos al intérprete de comandos

[Título original: Issuing Shell Commands]

Podemos usar el comando "shell" para enviar comandos de "shell" remotos a una instancia de emulador/dispositivo. Podemos enviar un simple comando sin tener que abrir una sesión remota de "shell" o también podemos abrir una sesión de shell en donde naveguemos y enviemos comandos UNIX.

Para enviar un simple comando sin ingresar a una sesión remota de "shell", usa el siguiente comando:

adb [-d {<ID><serialNumber>}] shell <shellCommand>

Para abrir una sesión remota de "shell" en una instancia de emulador/dispositivo, usa el siguiente comando:

adb [-d {<ID><serialNumber>}] shell

Cuando hayas terminado de ejecutar tus comando, usa "CTRL+D" o "exit" para cerrar la sesión de "shell".

Las siguientes secciones proveen más información sobre comandos de "shell" que tú podrías utilizar.

Examinando base de datos sqlite3 desde una shell remota

[Título original: Examining sqlite3 Databases from a Remote Shell]

Desde una sesión de shell remota, podemos usar "sqlite3", el cual es un programa de comandos de línea para administrar las base de datos "SQLite" creadas por las aplicaciones. La herramienta "sql3" incluye comandos de mucha utilidad, tales como ".dump" que permite imprimir el contenido de una tabla, y ".schema" que permite genera la sentencia "SQL CREATE" necesaria para reproducir una tabla existente. La herramienta también te provee la capacidad de ejecutar comando dinámicamente.

Para usar "sqlite3", ingresa a una sesión de "shell" remota en la instancia del emulador, tal como se describió anteriormente, y luego invoca la herramienta usando el comando "sqlite3". De manera opcional, al invocar "sqlite3" puedes especificar la ubicación completa de la base de datos que deseas explorar. Las bases de datos en el emulador o dispositivo son almacenadas en el directorio "/data/data/nombrepaquete/databases/".

A continuación se muestra dos ejemplos:

$ adb -d emulator-tcp-5557 shell
# sqlite3 /data/data/com.example.google.rss.rssexample/databases/rssitems.db
SQLite version 3.3.12
Enter ".help" for instructions
.... enter commands, then quit...
sqlite> .exit 

C:\Android SDK\android_sdk_windows_m3-rc20a\tools>adb shell
sqlite3 /data/data/com.google.android.providers.contacts/databases/contacts.db
sqlite> .tables
.tables
_deleted_people contact_methods peopleLookup
calls people phones
sqlite> .exit
.exit

Una vez que has invocado "sqlite3", puedes ingresar comandos "sqlite3" en la "shell". Pata terminar la sesión y retornar a la sesión de "shell" remota de "adb" usa el comando "exit" o "CTRL+D".

Otros comandos del intérprete de comandos

[Título original: Other Shell Commands]

Comando de shell: dumpsys
Descripción: Vacía el contenido de los datos del sistema.
Comentario: La herramienta "Dalvik Debug Monitor Service (DDMS)" ofrece un entorno integrado de depuración que encontrarás más sencillo de utilizar.

Comando de shell: dumpstate
Descripción: Vacía la información de estado a un archivo.
Comentario:

Comando de shell: logcat [<option>]... [<filter-spec>]...
Descripción: Habilita el "radio logging" e imprime la salida a la pantalla.
Comentario:

Comando de shell: dmesg
Descripción: Imprime los mensajes de depuración a la pantalla.
Comentario:

Comando de shell: start
Descripción: Activa (reinicializa) una instancia de emulador/dispositivo.
Comentario:

Comando de shell: stop
Descripción: Detiene la ejecución de una instancia de emulador/dispositivo.
Comentario:

Habilitando logcat

[Título original: Enabling logcat Logging]

El sistema de bitácora de Android provee un mecanismo para recolectar y ver la información de depuración del sistema. Bitácoras de varias aplicaciones y porciones del systema son recolectadas en una serie de áreas de memoria temporal, las cuales pueden ser vistas y filtradas a través del comando "logcat".

Usando comandos "logcat"

[Título original: Using logcat Commands]

Tú puedes usar el comando para ver y seguir el contenido de la bitácora del sistema. La sintaxis general de uso es:

[adb] logcat [<option>] ... [<filter-spec>] ...

Las secciones a continuación explican las especificaciones de filtrado y las opciones del comando. Para mayor información lee "Listado de opciones del comando logcat".

Tú puedes usar el comando "logcat" desde tu computador de desarrollo o desde una sesión de "shell" remota en una instancia de emulador/dispositivo. Para ver la salida de la bitácora en tu computador de desarrollo, usa el siguiente comando:

$ adb logcat

y desde la sesión de "shell" remota, usa el siguiente comando:

# logcat

Filtrando la salida de la bitácora

[Título original: Filtering Log Output]

Cada mensaje de bitácora de Android tiene una etiqueta y una prioridad asociada.

La etiqueta de un mensaje de bitácora es una pequeña cadena de caracteres indicando el componente de sistema donde el mensaje fue originado (por ejemplo, "View" para una vista del sistema).

La prioridad es uno de los siguientes caracteres, ordenados desde la más baja a la más alta prioridad:

V - Verbose (baja prioridad) 
D - Debug 
I - Info 
W - Warning 
E - Error 
F - Fatal 
S - Silent (alta prioridad, en la cual nada es impreso)

Tú puedes obtener una lista de etiquetas usadas en el sistema junto con las prioridades, ejecutando el comando "logcat" y examinando las primeras dos columnas de cada mensaje dado como: <priority>/<tag>.

A continuación hay un ejemplo de la salida de "logcat" que muestra un mensaje asociado con la prioridad de nivel "I" y con la etiqueta "ActivityManager":

Para reducir la salida de la bitácora a un nivel manejable, tú puedes restringir la cantidad de información usando expresiones que filtren estos datos. Las expresiones de filtro te permiten indicarle al sistemas las prioridad y etiquetas en las cuales tú estás interesado y así el sistema suprime todos los otros mensajes.

Una expresión de filtrado sigue el siguiente formato: "tag:priority ...", donde "tag" indica la etiqueta en la cual estamos interesados y "priority" indica el nivel mínimo de prioridad que deseamos examinar. Todos los mensajes para esa etiqueta que sean de la priodidad indica superior serán registrado en la bitácora. Podemos indicar cualquier número de especificaciones "tag:priority" es una expresión de filtrado. Las series de especificaciones son delimitadas por espacios en blanco.

A continuación verás un ejemplo de una expresión de filtrado que suprime todos los mensajes de bitácora excepto aquellos con la etiqueta "ActivityManager" cuya prioridad es "Info" o superior, y todos los mensajes con etiqueta "MyApp" con prioridad "Debug" o superior:

adb logcat ActivityManager:I MyApp:D *:S

El elemento final de la expresión "*:S", fija el nivel de prioridad de todas las etiquetas a "silent", de esa forma nos aseguramos de ver sólo aquellos mensajes con "View" y "MyApp". El uso de "*:S" es una excelente forma de asegurar que la salida de la bitácora está restringida a los filtros que nosotros hemos explícitamente indicado y así nuestros filtros actúan como una "lista blanca" de mensajes de bitácora.

La siguiente expresión desplega todos los mensajes de bitácora cuyo nivel de prioridad es "warning" o superior, para todas las etiquetas:

Si tú estás corriendo "logcat" desde tu computador de desarrollo (en vez de correrlo en una sesión de "shell" remota), también puedes fijar una expresión de filtrado por omisión. Para hacer esto exporta la variable de entorno "ANDROID_LOG_TAGS":

export ANDROID_LOG_TAGS="ActivityManager:I MyApp:D *:S"

NOTA: La variable de entorno "ANDROID_LOG_TAGS" no es exportada a la instancia del emulador/dispositivo, si tú estás corriendo "logcat" desde una sesión de "shell" remota o usando "adb shell logcat".

Controlando la salida de la bitácora

[Título original: Controlling Log Output Format]

Los mensaje de bitácora, además de las etiquetas y nivel de prioridad, contienen información de metadatos. Podemos modificar el formato de salida de los mensajes para que se desplegue determinada información de metadatos. Para hacer esto, usa la opción "-v" e indica uno de los siguientes formatos listados a continuación:

brief   - Desplega prioridad/etiqueta y PID del proceso que originó el mensaje (formato por omisión). 
process - Desplega sólo el PID. 
tag     - Desplega sólo prioridad/etiqueta. 
thread  - Desplega sólo proceso:thread y prioridad/etiqueta. 
raw     - Desplega toda la información del mensaje, sin metadatos. 
time    - Desplega la fecha, hora de invocación, prioridad/etiqueta y PID del proceso que originó el mensaje. 
long    - Desplega toda la información de metadatos y los mensajes separados por líneas en blanco.

A continuación está la sintaxis general para ejecutar "logcat" e indicar el formato de salida que deseas:

[adb] logcat [-v <format>]

Aquí hay un ejemplo que muestra cómo generar mensajes usando el formato "thread":

adb logcat -v thread

NOTA: Sólo puedes indicar un sólo formato de salida con la opción"-v".

Examinando bitácoras alternativas

[Título original: Viewing Alternative Log Buffers]

El sistema de bitácora de Android mantiene múltiples bitácoras circulares para registrar los mensajes de eventos, y no todos los mensajes son enviados a la bitácora circular por omisión. Para examinar mensajes adicionales, puedes correr "logcat" con la opción "-b", lo cual te permitirá ver bitácoras circulares alternativas. Puedes examinar cualquiera de las siguientes bitácoras alternativas:

radio  - Muestra la bitácora de mensajes relacionados con radio/telefonía.
events - Muestra la bitácora de mensajes conteniendo mensajes asociados a eventos.
main   - Muestra la bitácora principal de mensajes (por omisión)

Sintaxis de uso de la opción "-b":

[adb] logcat [-b <buffer>]

Aquí hay un ejemplo de cómo examinar la bitácora que contiene mensajes asociados a "radio" y telefonía:

adb logcat -b radio

Examinando Viewing stdout y stderr

[Título original: Viewing stdout and stderr]

Por omisión, el sistema Android tiene asociado "stdout" y "stderr" ("System.out" y "System.err") con "/dev/null". En procesos que corren "Dalvik VM", el sistema puede escribir una copia de los mensajes de salida a un archivo de bitácora. En este caso, el sistema escribe los mensajes de bitácora usando las etiquetas "stdout" y "stderr", ambas con prioridad "I".

Para rutear la salida de esta forma, debes detener la instancia del emulador/dispositivo y entonces usar el comando de shell "setprop" para habilitar el redireccionamiento de la salida. Aquí se muestra cómo hacerlo:


$ adb shell stop
$ adb shell setprop log.redirect-stdio true
$ adb shell start

El sistema mantiene esta configuración hasta que tu termines la ejecución de la instancia del emulador/dispositivo. Para usar esta configuración por omisión en la instancia del emulador/dispositivolt debes modificar el archivo "/data/local.prop" en el dispositivo.

Listado de las opciones del comando logcat

[Título original: Listing of logcat Command Options]

Opción: -b <buffer>
Descripción: Carga una bitácora alternativa para ser examinada, tal como "event" o "radio".

Opción: -c
Descripción: Borra completamente la bitácora y finaliza.

Opción: -d
Descripción: Vacía la bitácora a la pantalla y finaliza.


Opción: -f <filename>
Descripción: Escribe los mensajes de bitácora al archivo "filename". Por omisión es "stdout".

Opción: -g
Descripción: Imprime el tamaño de la bitácora y finaliza.

Opción: -n <count>
Descripción: Fija el número máximo de vueltas de una bitácora a "count". El valor por omisión es "4". Requiere la opción "-r".

Opción: -r <kbytes>
Descripción: Rota el archivo de bitácora cada "kbytes" de datos. El valor por omisión es "16". Requiere la opción "-f".

Opción: -s
Descripción: Fija el filtro a "silent".

Opción: -v <format>
Descripción: Fija el formato de salida de los mensajes de bitácora. Por omisión, el formato es "brief".

Deteniendo el servidor "adb"

[Título original: Stopping the adb Server]

En algunos casos, podrías necesitar detener el proceso del servidor "adb" y luego reiniciarlo. Por ejemplo, si "adb" no está respondiendo a un comando. En este ejemplo, detener y reiniciar el proceso podría resolver el problema.

Para detener el proceso del servidor "adb", usa el comando "kill-server". Posteriormente, puedes reiniciar el servidor enviando cualquier comando "adb".

Información adicional

[Título original: No es parte de la documentación oficial]

Ejemplo salida : adb shell dmesg

[Título original: No es parte de la documentación oficial]

C:\android_sdk_windows_m3-rc22a\tools>adb shell dmesg 

<5>Linux version 2.6.23-gcc3bc3b4 (arve@arvelnx.corp.google.com) (gcc version 4.2.1) #3 Tue Oct 30 16:28:18 PDT 2007 
<4>CPU: ARM926EJ-S [41069265] revision 5 (ARMv5TEJ), cr=00003137 
<4>Machine: Goldfish 
<4>Memory policy: ECC disabled, Data cache writeback 
<7>On node 0 totalpages: 24576 
<7> DMA zone: 192 pages used for memmap 
<7> DMA zone: 0 pages reserved 
<7> DMA zone: 24384 pages, LIFO batch:3 
<7> Normal zone: 0 pages used for memmap 
<7> Movable zone: 0 pages used for memmap 
<4>CPU0: D VIVT write-through cache 
<4>CPU0: I cache: 4096 bytes, associativity 4, 32 byte lines, 32 sets 
<4>CPU0: D cache: 65536 bytes, associativity 4, 32 byte lines, 512 sets 
<4>Built 1 zonelists in Zone order. Total pages: 24384 
<5>Kernel command line: qemu=1 console=null android.checkjni=1 android.ril=ttyS0 
...

Manos a la obra - Tutorial - Ejercicio #3

2007-12-12T18:20:00.000-08:00

Documento original : Tutorial: Notepad Exercise 3

En este ejercicio, usaremos el ciclo de vida de los métodos "callback" asociados a un evento para almacenar y recuperar los datos del estado de la aplicación.

Este ejercicio demostrará:

El ciclo de vida de un evento y cómo una aplicación puede hacer uso de ellos.
Técnicas para mantener el estado de la aplicación.

Paso 1

La aplicación que terminamos de desarrollar en el tutorial anterior tiene un grave defecto. Si presionas el botón "Back" del dispositivo cuando estás editando una anotación, esto causará que se lance una "exception" producto que la "Activity" que espera datos no podrá recuperar el texto que estaba siendo editado.

Para remediar lo anterior, moveremos parte de la funcionalidad de creación y edición de una anotación dentro de la clase "NoteEdit" y utilizaremos el completo ciclo de vida de una "Activity" en la edición de una anotación.

Importa el proyecto "Notepadv3" dentro de Eclipse. Si se te presenta un error con el archivo "AndroidManifest.xml" o con el archivo "android.zip", abre el menú de contexto del proyecto y selecciona la opción "Android Tools->Fix Project Properties". El punto de partida de este ejercicio es el proyecto "Notepadv2".
Remove the NoteEdit code to parse out the title and body from the extras bundle.
Vamos a usar la clase "DBHelper" para accesar las anotaciones directamente desde la base de datos. Todo lo que debemos entregar a "NoteEdit" es el "rowId" (si es que estamos editando, pero si estamos creado no necesitamos entregarla nada). Con este nuevo enfoque no tendremos que utilizar las propiedades que estaban siendo pasadas como datos del paquete.
Remueve las siguientes líneas desde la clase "NoteEdit":

String title = extras.getString(Notepadv3.KEY_TITLE);
String body = extras.getString(Notepadv3.KEY_BODY);

también elimina las siguientes líneas:

if (title != null) {
titleText.setText(title);
}
if (body != null) {
bodyText.setText(body);
}

NOTA: Podrías reemplazar el bloque "if (extras != null) {...}" con el operador ternario:

rowId = xtras != null ? extras.getLong(Notepadv3.KEY_ROW_ID) : null;

Paso 2

Declara la siguiente nueva propiedad dentro de la clase "NoteEdit":

private DBHelper dbHelper;

luego, crea una instancia de "DBHelper" en el método "onCreate()", justo debajo del llamado al método "super.onCreate()":

dbHelper = new DBHelper(this);

Paso 3

Necesitamos verificar el argumento de "onCreate(Bundle ...)" para comprobar el "rowId" y así valor si la anotación que estaba siendo editada ha sido congelada.

Reemplaza al siguiente código que inicializa "rowId":

rowId = null; 
Bundle extras = getIntent().getExtras();
if (extras != null) {
rowId = extras.getLong(Notepadv3.KEY_ROW_ID);
}

por este código:

rowId = icicle != null ? icicle.getLong(Notepadv3.KEY_ROW_ID) : null;
if (rowId == null) {
Bundle extras = getIntent().getExtras(); 
rowId = extras != null ? extras.getLong(Notepadv3.KEY_ROW_ID) : null;
}

NOTA: Si "rowId" no pudo recuperarse a partir de "icicle", entonces debemos recuperarlo desde el paquete de datos.

Paso 4

A continuación, necesitamos llenar las propiedades basándonos en el "rowId" que tenemos. Para ello agrega el siguiente llamado:

populateFields();

antes de la sentencia "confirmButton.setOnClickListener(...)"

Paso 5

Eliminaremos todo el código asociado con la creación del paquete de datos y la asignación de valores en el método controlador de evento "onClick(...)". La "Activity" ya no necesita devolver ninguna información adicional a quien la invocó. También podemos utilizar una versión corta del método "setResult()":

public void onClick(View arg0) 
{
setResult(RESULT_OK);
finish();
}

La nueva versión del método "onCreate(...)" debería quedar de la siguiente forma:

@Override
protected void onCreate(Bundle icicle) 
{
super.onCreate(icicle);
dbHelper = new DBHelper(this); 
setContentView(R.layout.note_edit);

titleText = (EditText) findViewById(R.id.title);
bodyText = (EditText) findViewById(R.id.body);

Button confirmButton = (Button) findViewById(R.id.confirm);

rowId = icicle != null ? icicle.getLong(Notepadv3.KEY_ROW_ID) : null;
if (rowId == null) {
Bundle extras = getIntent().getExtras(); 
rowId = extras != null ? extras.getLong(Notepadv3.KEY_ROW_ID) : null;
} 

this.populateFields(); 

confirmButton.setOnClickListener(
new View.OnClickListener() 
{
public void onClick(View arg0) {
setResult(RESULT_OK);
finish();
} 
}
);
return;
}

Paso 6

Declararemos el método "populateFields()".

    private void populateFields() 
    {
        if (rowId != null) 
        {
            DBHelper.Row row = dbHelper.fetchRow(rowId);
            if (row.rowId > -1) 
            {
                titleText.setText(row.title);
                bodyText.setText(row.body);            
            }            
        }
        return;
    }

Paso 7

¿Por qué es tan importante manipular los eventos del ciclo de vida?

Si tú estás acostumbrado a tener pleno control sobre tus aplicaciones, podrías estarte preguntando por qué es necesario este concepto de ciclo de vida. La razón es porque en Android tú no tienes el control de tus "Activity" sino que es el sistema operativo.

Tal como ya hemos visto, el modelo de Android está basado en la colaboración mutual entre "Activity" llamándose unas a otras. Cuando una "Activity" llama a otra, la actual "Activity" es pausada y podría ser eliminada posteriormente si los recursos disponibles comienzan a escasear.
Si esto llegara a ocurrir, tu "Activity" tendrá la oportunidad de guardar su actual estado para que más tarse cuando sea restaurada puede volver al estado en el cual se encontrada antes de ser eliminada.

Android tiene un ciclo de vida muy bien definido. Los eventos del ciclo de vida ocurren incluso si tú no estás pasando el control a otra "Activity" en forma explícita. Por ejemplo, una llamada podría ser recibida cuando el usuario está operando tu aplicación. Si esto ocurre, tu aplicación quedará en segundo plano mientras otra aplicación se encarga de la llamada.

Volvamos al tutorial y a realizar cambios en la clase "NoteEdit". A continuación, sobreescribiremos los métodos "onFreeze()", "onPause()" y "onResume()". Estos son nuestros métodos del ciclo de vida (incluido "onCreate()").

Método onFreeze() : este método es llamado por Android si la "Activity" está siendo detenida y probablemente será eliminada antes de que pueda ser reinicializada. Esto significa que dentro de este método la aplicación debería guardar cualquier estado que sea necesario para reiniciarse en las mismas condiciones que estaba al momento de ser detenida. Este método es la contra parte del método "onCreate(Bundle" y de hecho el argumento que este método recibe es el mismo que tú construyes como "outState" en el método "onFreeze()".

Métodos onPause() y onResume() : estos métodos son complementarios. El método "onPause()" es siempre llamado cuando una "Activity" finaliza, incluso si hemos sido nosotros quien lo ha programado. Nosotros usaremos este método para guardar la actual anotación en la base de datos. Una buena práctica es liberar cualquier recursos que sea posible en "onPause()", y de esa manera mantener bajo el nivel de recursos cuando nuestra aplicación esta en un estado pasivo. Por esta razón, vamos a cerrar la conexión con la base de datos y asignaremos el valor null al objeto "DBHelper" (de esa manera facilitamos el trabajo del "Garbage Collector"). En el método "onResume()" recrearemos la instancia de "DBHelper" para poder recuperar la anotación desde la base de datos.

A continuación está el código del método "onFreeze()":

@Override
protected void onFreeze(Bundle outState) 
{
super.onFreeze(outState);
outState.putLong(Notepadv3.KEY_ROW_ID, rowId);
}

A continuación está el código del método "onPause()":


@Override
protected void onPause() 
{
super.onPause();
saveState();
dbHelper.close();
dbHelper = null;
return;
}

A continuación está el código del método " onResume()":


@Override
protected void onResume() 
{
super.onResume();
if (dbHelper == null) {
dbHelper = new DBHelper(this);
}
populateFields();
}

Paso 8

A continuación definiremos el método "saveState()", el cual guarda los datos en la base de datos.

private void saveState() 
{
String title = titleText.getText().toString();
String body = bodyText.getText().toString();
if (rowId == null) {
dbHelper.createRow(title, body);
} else {
dbHelper.updateRow(rowId, title, body);
}
}

Paso 9

Ahora saquemos modificaremos el método "onActivityResult()" de la clase "Notepadv3". Toda la lógica de recuperación y actualización está en el ciclo de vida de la clase "NoteEdit", por lo tanto lo único que el método "onActivityResult()" debe realizar es actualizar la vista de los datos. El código del método es mostrado a continuación:


@Override
protected void onActivityResult(
int requestCode, int resultCode, String data, Bundle extras) 
{
super.onActivityResult(requestCode, resultCode, data, extras);
fillData();
}

Paso 10

En el método "onListItemClick()" de la clase "Notepadv3" también debemos eliminar las líneas que agregar el título y cuerpo de la anotación al paquete de datos.
i.putExtra(KEY_TITLE, rows.get(position).title); i.putExtra(KEY_BODY, rows.get(position).body);

Paso 11

La aplicación esta lista para ser ejecutada.

Manos a la obra - Ciclo de vida de una aplicación Android

2007-12-12T08:17:00.000-08:00

Documento original: Life Cycle of an Android Application

Ciclo de vida de una aplicación Android

[Título original: Life Cycle of an Android Application]

En muchos casos, una aplicación Android corre dentro de su propio proceso Linux. Este proceso es creado para la aplicación cuando parte de su código necesita ser ejecutado, y continuará vivo hasta que ya no sea requerido y el sistema reclame su memoria para asignársela a otra aplicación.

Una característica importante, y poco usual, de Android es que el tiempo de vida de un proceso no es controlado directamente por la aplicación. En lugar de esto, es el sistema quien determina el tiempo de vida del proceso basado en el conocimiento que tiene el sistema de las partes de la aplicación que están corriendo, qué tan importante es la aplicación para el usuario y cuánta memoria disponible hay en un determinado momento.

Es muy importante tener en consideración cómo los distintos componentes de una aplicación (en particular "Activity", "Service" y "IntentReceiver") impactan de el tiempo de vida del proceso asociado con una aplicación. Si estos componentes no son empleados de manera apropiada, el sistema detendrá el proceso de la aplicación aún cuando se esté haciendo algo importante.

Un típico ejemplo de lo anterior es un "IntentReceiver" que inicia un "thread" cuando recibe un "Intent" en su método "onReceiveIntent()" y entonces finaliza el método y devuelve el control. Una vez que el método devuelve el control, el sistema considera que el "IntentReceiver" no continúa activo y por lo tanto el proceso asociado a él ya no se requiere mantener corriendo (a menos que otro componente de la aplicación esté activo dentro de él). Debido a esto, el sistema en cualquier momento que requiera memoria eliminará el proceso y como consecuencia también el "thread" que fue creado anteriormente. La solución a este problema es iniciar un "Service" desde el "IntentReceiver", de esa manera el sistema sabrá que después de que "IntentReceiver" finalice aún habrá un trabajo activo asociado al proceso.

Para determinar que procesos deberían ser eliminados ante una condición de baja memoria, Android ordena los procesos en una estructura jerárquica y asignándole a cada proceso una determinada "importancia" basada en los componentes que están corriendo dentro de ellos y el estado de aquellos componentes.

De acuerdo a esta jerarquía de importancia se distinguen los siguientes tipos de procesos:

Foreground process : (proceso de primer plano) es un proceso que hospeda una "Activity" en la superficie de la pantalla y con la cual el usuario está interactúando (su método "onResume()" ha sido llamado) o un "IntentReceiver" está corriendo (su método "onReceiveIntent()" se está ejecutando). Dentro de Android debería haber sólo unos pocos procesos que dentro de esta categoría y estos procesos sólo serán eliminados cómo último recurso, si es que la memoria está tan baja que ni siquiera estos procesos pueden continuar corriendo. Si esta fuera la situación, el dispositivo probablemente alcanzó un "memory paging state" y esta acción es necesaria para mantener la interface del usuario con capacidad para responder al usuario.

Visible process : (proceso visible) es un proceso que hospeda una "Activity" que es tá visible en la pantalla, pero no en el primer plano (su método "onPause()" ha sido llamado). Esto podría ocurrir, si por ejemplo, la actividad de primer plano está siendo desplegada en la pantalla con la apariencia de un cuadro de diálogo que permite que la actividad previa pueda ser vista detrás de ella. Este tipo de proceso es considerado extremadamente importante y no será eliminado a menos sea extrictamente necesario para mantener a todos los procesos de primer plano corriendo.

Service process : (proceso de servicio) es un proceso que hospeda a un "Service" que ha sido inicializado con el método "startService()". Aunque estos procesos no son directamente visibles al usuario, generalmente están haciendo tareas que para el usuario son muy importantes (tales como reproducir un archivo mp3 o mantener una conexión con un servidor de contenidos), por lo tanto el sistema siempre tratará de mantener esos procesos corriendo a menos que los niveles de memoria comiencen a comprometer el funcionamiento de los procesos de primer plano.

Background process : (proceso de fondo) es un proceso que hospeda una "Activity" que no es actualmente visible al usuario (su método "onStop()" ha sido llamado). Si estos procesos son eliminados no tendrán un directo impacto en la experiencia del usuario. Basado en el hecho que la "Activity" ha sido programada para implementar correctamente su ciclo de vida, el sistema puede eliminar estos procesos en cualquier momento para reclamar la memoria que estén usando para entregársela a cualquiera de los tres tipos de procesos anteriormente descritos. Generalmente, hay muchos de estos procesos corriendo, por lo tanto el sistema mantiene una lista "LRU" para asegurar que el último proceso visto por el usuario sea el último en ser eliminado en caso que se requiere recolectar memoria.

Empty process : (proceso vacío) es un proceso que no hospeda a ningún componente de aplicación activo. La única razón para mantener ese proceso es tener un "cache" que permita mejorar el tiempo de activación en la próxima oportunidad que un componente de su aplicación requiera correr. Como consecuencia de esto, el sistema con frecuencia va a eliminar estos procesos para mantener el balance entre los recursos de cache utilizados por estos procesos con los utilizados por los "cache" del kernel del sistema.

Al momento de clasificar un proceso, el sistema toma el nivel más importante de todos los componentes activos de un proceso. Lee sobre la documentación de "Activity", "Service" y "IntentReceiver" para estudiar más detalles de cómo cada uno de estos componentes contribuyen en el ciclo de vida del proceso. La documentación de cada una de estas clases también entregan más detalles de cómo estos componentes impactan en el ciclo de vida de una aplicación.

IMPORTANTE NOTICIA!

2007-12-12T04:49:00.000-08:00

Documentación + Experiencia Práctica

He decidido comenzar a publicar cada día algo nuevo que haya aprendido sobre Android. Si se fijan, además de traducir complemente la parte #2 del tutorial de Android, también he publicado tres notas ¿COMO HACER?

Creo que en la medida que vaya entregándoles la documentación clara y algunos consejos de cómo sacarle el mayor provecho a las herramientas y plataforma, el contenido de este blog se convertirá en una buena referencia para los hablantes hispanos.

Si alguno de ustedes tiene un documento interesante de Android (y el código fuente) y desea que haga una traducción de él, sólo agreguen un comentarios con la URL del documento.

Que tengan un excelente día.

¿CÓMO HACER? - Simular una llamada entrante

2007-12-11T20:37:00.000-08:00

Llámame

A continuación explicaré cuales son los pasos que debes realizar para simular una llamada entrante:

Abre una aplicación "telnet" (la que sea de tu gusto).
Luego ejecuta el comando "o 127.0.0.1 5554". La "o" es de "open". A continuación del comando "o" colocas la direción IP del "Android Emulator" y su puerto de escucha (en mi caso, tengo el emulador corriendo en mi laptop asi es que utilicé la dirección "localhost".
Una vez que el emulador acepte tu solicitud de conexión, verás un mensaje similar a "Android Console: type 'help' for a list of commands".
Finalmente, ejecuta el comando "gsm call unnúmerotelefónico".Donde "unnúmeroteléfonico"es el número del teléfono que supuestamente está haciendo el llamado. Por ejemplo, "gsm call 1234567".

NOTA: Puedes agregar algunos teléfonos a tu libreta de contactos y posteriormente usar aquellos números para hacer simulaciones de llamadas de personas que conoces. Así la experiencia resulta más entretenida.

NOTA: Si quieres escuchar el ring de la llamada deberías ejecutar el emulador a través del comando "./emulator -useaudio" o "emulator.exe -useaudio".

¿CÓMO HACER? - Cargar un archivo al emulador

2007-12-11T20:02:00.000-08:00

En algunas ocaciones es necesario cargar archivo de música o video al emulador, para posteriormente reproducirlos utilizando las APIs de Android.

A continuación están las instrucciones para cargar un archivo (mp3, etc) al emulador:

Abre una consola en tu sistema operativo.
Navega hasta el directorio "Android Tools" (Por ejemplo: C:\android_sdk_windows_m3-rc22a\tools).
Ejecuta el comando "adb push [origen]/nombrearchivo [destino]nombrearchivo".

Ejemplo:

C:\android_sdk_windows_m3-rc22a\tools>
adb push C:\basura\misirlou.mp3 /tmp/mismp3/misirlou.mp3
1129 KB/s (0 bytes in 6451012.005s)

¿CÓMO HACER? - Eliminar una aplicación del emulador

2007-12-11T19:13:00.000-08:00

Documento Original : Removing an Android Application

NOTA: El emulador de Android debe estar ejecutándose.

Para eliminar una aplicación que haz instalado en el emulador, lo que debes hacer es:

Abre una consola en tu sistema operativo.
Navega hasta el directorio "Android Tools" (Por ejemplo: C:\android_sdk_windows_m3-rc22a\tools).
Ejecuta el comando "adb shell". Si el emulador no se está ejecutando vas a ver el siguiente mensaje:

C:\android_sdk_windows_m3-rc37a\tools>adb shell
* daemon still not running
*error: no device

Navega al directorio "data/app", para ello ejecuta el comando "cd data/app".
(Opcional) Lista los archivos de este directorio con el comando "ls".
Finalmente elimina el archivo de tu aplicación con el comando "rm tuaplicacion.apk"

Ejemplo de la salida de una consola:

C:\android_sdk_windows_m3-rc22a\tools>adb shell
#cd data/appcd
data/app
# ls
ls
-rw-rw-rw- root root 31483 2007-12-11 20:09 notepad2.apk
-rw-rw-rw- root root 22539 2007-12-11 19:24 notepad1.apk
-rw-rw-rw- root root 28835 2007-12-09 17:00 comunicacion-xpmm-01.apk
-rw-r--r-- system system 1325834 2007-11-14 13:41 ApiDemos.apk
-rw-rw-rw- root root 26455 2007-12-09 12:40 p2p-services-01.apk
-rw-rw-rw- root root 35537 2007-12-10 14:19 friend-finder-01.apk
-rw-rw-rw- root root 29148 2007-12-10 22:08 lista-con-iconos.apk
-rw-rw-rw- root root 18974 2007-12-10 22:18 lista-de-contactos.apk
-rw-rw-rw- root root 14388 2007-12-10 22:35 open-browser-01.apk
# rm notepad1.apk
rm notepad1.apk
#

Manos a la obra - Tutorial - Ejercicio #2

2007-12-11T11:21:00.000-08:00

Documento original: Tutorial: Notepad Exercise 2

En este ejercicio agregaremos una segunda "Activity" a nuestra aplicación de anotaciones y permitiremos que el usuario cree, edite y borre anotaciones. La nueva "Activity" asumirá la responsabilidad de crear nuevas anotaciones al colectar los datos de entrada del usuario y empaquetarlos y devolverlos a la "Activity" que la invocó.

Este ejercicio demostrará:

Desarrollo de una nueva "Activity" y cómo agregarla al archivo "Android manifest".
Invocación asincrónica de otra "Activity" usando "startSubActivity()".
Paso de datos entre "Activity" ("bundles").
Cómo utilizar características más avanzadas de diseño de pantalla.

Paso #1

Importa el proyecto "Notepadv2" de la misma forma en que lo describí en el tutoríal anterior. Los archivos de este proyecto están localizados en el directorio "NotepadCodeLab". Si se te presenta un error con el archivo "AndroidManifest.xml" o con el archivo "android.zip", abre el menú de contexto del proyecto y selecciona la opción "Android Tools->Fix Project Properties".

Expande el proyecto "Notepadv2" y dale un vistazo general:

Abre y examina el archivo "strings.xml" (directorio "res/values"). Verás la declaración de nuevas cadenas de texto, las cuales las usaremos en las nuevas funcionalidades.
Abre y examina el encabezado de la clase "Notepadv2". Notarás que también hay algunos cambios: declaraciones de nuevas constantes y propiedades.
También notarás que el método "fillData()" ha sido modificado para usar la propiedad "rows" en vez de una variable local.
Adicionalmente, hemos sobreescrito nuevos métodos: "onListItemClick()" y "onActivityResult()".

Paso #2

Revisa el método "onCreate()", verás que no ha cambiado desde la versión anterior.

Paso #3

Debemos agregar la opción "Delete Note" al menú de la "Activity". Para esto:

En el método "onCreateOptionsMenu()" agrega la siguiente línea:

menu.add(0, DELETE_ID, R.string.menu_delete);

Ahora, el método debería verse así:

@Override 
public boolean onCreateOptionsMenu(Menu menu) 
{ 
super.onCreateOptionsMenu(menu); 
menu.add(0, INSERT_ID, R.string.menu_insert); 
menu.add(0, DELETE_ID, R.string.menu_delete); 
return true; 
}

Paso 4

En el método "onMenuItemSelected()" agrega el siguiente fragmento de código:

case DELETE_ID: 
dbHelper.deleteRow(rows.get(getSelection()).rowId); 
fillData(); 
break;

Este código usa el método "getSelection()" perteneciente a "ListActivity", el cual nos indica cual es el actual elemento seleccionado de la lista. Luego, referenciamos el registro de esa anotación y finalmente tomamos el valor de la propiedad "rowId". Es este valor el que finalmente utilizamos con "deleteRow" para borrar el registro.

Posteriormente, llamamos al método "fillData()" para mantener todo actualizado.
El método debería quedar de la siguiente forma:

@Override 
public boolean onMenuItemSelected(int featureId, Item item) 
{ 
super.onMenuItemSelected(featureId, item); 
switch(item.getId()) { 
case INSERT_ID: 
createNote(); 
fillData(); 
break; 
case DELETE_ID: 
dbHelper.deleteRow(rows.get(getSelection()).rowId); 
fillData(); 
break; 
} 
return true; 
}

Paso 5

Ahora, modificaremos el cuerpo del método "createNote()":

Definiremos un "Intent" para crear una anotación ("ACTIVITY_CREATE"). Los argumentos que utilizaremos será "this" y la clase "NoteEdit". A continuación, gatillaremos el "Intent" usando el método "startSubActivity()".

NOTA: La clase "NoteEdit" será definida en unos momentos.

NOTA: En este ejemplo, nuestro "Intent" utiliza el nombre específico de una clase. Mientras esto es adecuado para determinadas circunstancias, lo más común es invocar un "Intent" usando una "Action" y una "URI". Ver "android.content.Intent" para más información.

Paso 6

Modificaremos el cuerpo del método "onListItemClick()".

El método "onListItemClick()" sobreescribe el método que es llamado cuando un usuario selecciona un elemento de la lista. Este método entrega 4 parámetros:

Objeto ListView : referencia al objeto desde el cual fue invocado el elemento.
Objeto View : referencia al objeto que fue seleccionado dentro de la ListView.
Un entero con la posición del elemento seleccionado.
Un entero con la identificación del elemento que fue seleccionado.

En nuestro ejemplo, podemos ignorar los dos primeros parámetros (tenemos sólo una "ListView" desde la cual el elemento pudo ser seleccionado). También ignoraremos la identificación del elemento. Todo lo que nos interesa por ahora es la posición del elemento que el usuario seleccionó. Utilizaremos esta posición para recuperar los datos de la anotación desde la lista y los empaquetamos para enviarlo a la "Activity" "NoteEdit".

Este método crea el "Intent" para editar la anotación usando la clase "NoteEdit". Luego, agregamos todos los datos al "Intent" (título, cuerpo de la anotación y la identificación). Finalmente, gatillamos el "Intent" invocando al método "startSubActivity()" con los argumentos "ACTIVITY_EDIT" y la clase "NoteEdit".

super.onListItemClick(l, v, position, id); 
Intent i = new Intent(this, NoteEdit.class); 
i.putExtra(KEY_ROW_ID, rows.get(position).rowId); 
i.putExtra(KEY_BODY, rows.get(position).body); 
i.putExtra(KEY_TITLE, rows.get(position).title); 
startSubActivity(i, ACTIVITY_EDIT);

El método "putExtra()" permite agregar elementos adicionales al paquete del "Intent".

Paso 7

A continuación modificaremos el método "onActivityResult()".

El método "onActivityResult()" sobreescribe un método que es invocado cuando una sub "Activity" finaliza su tarea. Los parámetros que este método entrega son:

requestCode : s el código original utilizado en la invocación del "Intent" (en nuestro caso podrá ser "ACTIVITY_CREATE" o "ACTIVITY_EDIT").
resultCode : es el resultado (o código de error) del llamado. Este valor debería ser cero si todo fue correcto y valor distinto para indicar que algo falló. Existen algunos códigos predefinidos que pueden ser utilzados, pero también pueden definirse nuevos códigos para errores más específicos.
data : esta es una cadena de texto que es utilizada para recibir algún tipo de información descriptiva (por ejemplo: el texto que el usuario escribió en un cuadro de diálogo). Esto es útil únicamente cuando tenemos sólo una cosa que devolver. Si requerimos retornar más información, debemos usar "extras".
extras : este parámetro entrega los "extras bundle" (si es que existen) que retornó el "Intent" invocado.

La combinación de "startSubActivity()" y "onActivityResult()" puede ser vista como un llamado asincrónico a un procedimiento remoto ("asynchronous RPC" o "remote procedure call"). Esta es la forma recomendada para que una "Activity" invoque a otra "Activity" y compartir servicios.

A continuación está el código completo de este método:

@Override 
protected void onActivityResult(int requestCode, int resultCode, String data, Bundle extras) 
{ 
super.onActivityResult(requestCode, resultCode, data, extras); 

switch(requestCode) { 
case ACTIVITY_CREATE: 
String title = extras.getString(KEY_TITLE); 
String body = extras.getString(KEY_BODY); 
dbHelper.createRow(title, body); 
fillData(); 
break; 
case ACTIVITY_EDIT: 
Long rowId = extras.getLong(KEY_ROW_ID); 
if (rowId != null) { 
String editTitle = extras.getString(KEY_TITLE); 
String editBody = extras.getString(KEY_BODY); 
dbHelper.updateRow(rowId, editTitle, editBody); 
} 
fillData(); 
break; 
} 
return; 
}

En este método distinguimos los resultados de dos "Activity": "ACTIVITY_CREATE" y "ACTIVITY_EDIT".
En el caso de "ACTIVITY_CREATE", tomamos el título y el cuerpo desde "extras" para usarlos en la creación de la anotación.
En el caso de "ACTIVITY_EDIT", tomamos además el "KEY_ROW_ID" para localizar el registro que deseamos actualizar.
El método "fillData()" al final nos asegura que todo será actualizado.

Paso 8

Abre el archivo "note_edit.xml" y revísalo. Este archivo contiene la definición de la pantalla que será usada para editar nuestras anotaciones.

Este archivo hace uso de un nuevo parámetro: "android:layout_weight" (en este caso tiene el valor "1").

layout_weight es usado en "LinearLayouts" para asignar a las vistas un nivel de "importancia" dentro del diseño de la pantalla. Todas las vistas tienen un valor por omisión de cero para "layout_weight", lo cual significa que ellas pueden ocupar el espacio que requieran para ser desplegadas. Al asignar un valor mayor que cero hará que el resto del espacio disponible sea dividido entre el padre de acuerdo al valor de "layout_weight" y su proporción con el total de "layout_weight", especificado en el actual trazado y en otras vistas.

Para dar un ejemplo de lo anterior, digamos que tenemos una etiqueta de texto y dos áreas de edición en un vista horizontal. La etiqueta de texto no tiene especificado valor para su "layout_weight", por lo tanto tomará el mínimo espacio requerido para desplegarse. Si el valor de "layout_weight" para las áreas de texto es "1", el restanto espacio dentro del área definida por el padre será dividida entre ambas. Si la primera área tuviera un valor de "1" y la segunda un valor de "2" para "layout_weight", entonces un tercio del espacio disponible será entregado a la primera área y los dos restantes a la segunda.

Este diseño de pantalla también demuestra cómo anidar múltiples esquemas para así lograr complejos trazados de pantalla. En este caso, el esquema horizontal lineal está anidado dentro de uno vertical, lo cual permite que la etiqueta del título y el área de edición estén una al lado de otra.

Paso 9

Crea una clase llamada "NoteEdit" y que extienda "android.app.Activity".

Esta es la primera vez que crearemos una "Activity" sin la ayuda del "Android Eclipse plugin". Al hacerlo de esta manera, el método "onCreate()" no es automáticamente etiquetado con la anotación de sobreescritura. Es difícil imaginar una "Activity" que no sobreescriva el método "onCreate()".

A continuación están las instrucciones en detalle:

Abre el menú de contexto del paquete "com.google.android.demo.notepad2" y selecciona "New->Class".
Escribe en el campo "Name:" el nombre de la clase ("NoteEdit").
En el campo "Superclass:", escribe "android.app.Activity" o puedes simplemente escribir "Activity" y presionar "Ctrl-Space" (Windows y Linux) para invocar el asistente de código y encontrar path completo del paquete en el cual está esta clase.
Presiona el botón "Finish".
En el editor de texto abre el menú de contexto y selecciona la opción "Source", luego selecciona "Override/Implement Methods...".
Busca el método "onCreate(Bundle)" y selecciónalo.
Presiona el botón "OK".

Paso 10

Completaremos el código del método "onCreate()".

Haremos las declaraciones necesarias para definir el título de nuestra "Activity" ("Edit Note"). Este valor está definido en el archivo "strings.xml". Aquí también definiremos que la vista que utilizaremos será aquella definida en el archivo "note_edit.xml layout". Después de esto, podemos asociar a objetos Java las vistas correspondientes al título, el cuerpo de la anotación y el botón de confirmación. De esta forma, nuestro código puede usarlos para asignar y recuperar el texto del título y el cuerpo; y además asociar cñodigo al evento gatillado cuando el usuario presiona el botón de confirmación.

Los valores que fueron enviados por la "Notepadv2" serán extraidos desde el paquete y usados para llenar el título y el cuerpo de la anotación. La identificación de la anotación la almacenaremos para saber que registro estamos editando.

Asociación de la "Activity" con un esquema:

setContentView(R.layout.note_edit);

Examinar el esquema de pantalla para encontrar el título, el cuerpo y el botón de confirmació. Utilizamos los identificadores generados en la clase "R" y luego los convertimos al tipo apropiado.

titleText = (EditText) findViewById(R.id.title);
bodyText = (EditText) findViewById(R.id.body);
Button confirmButton = (Button) findViewById(R.id.confirm);

NOTA: "titleText" y "bodyText" son propiedades de la clase que aún no hemos definido.

Declarar una propiedad llamada "rowId", la cual almacenará la identificación del registro editado.

private Long rowId;

Agregar código para inicializar el título, cuerpo y la propiedad "rowId" a partir de los datos extraidos del paquete recibido desde "Notepadv2".

rowId = null;
Bundle extras = getIntent().getExtras();
if (extras != null) {
String title = extras.getString(Notepadv2.KEY_TITLE);
String body = extras.getString(Notepadv2.KEY_BODY);
rowId = extras.getLong(Notepadv2.KEY_ROW_ID);

if (title != null) {
titleText.setText(title);
}
if (body != null) {
bodyText.setText(body);
}
}

Definir un controlador para el evento clic del botón de confirmación. Esto lo hacemos utilizando el método "onClickListener()".

NOTA: Los controladores de eventos ("listeners") son uno de los aspectos más difíciles de entender en la implementación de una "UI", pero lo que intentamos hacer aquí es bastante simple. Lo que deseamos hacer es simplemente llamar al método "onClick()" cuando el usuario presione el botón de confirmación. Dentro de este método podremos hacer los necesario para devolver los valores ingresados por el usuario al "Intent" que llamo a esta "Activity". La técnica empleada en este código se llama "anonymous inner class". Resulta enredado de leer a menos que hayas visto este patrón anteriormente, pero por ahora sólo nos interesa usar este código a modo de receta de cómo invocar un método como reacción a un evento de la "UI".

Paso 11

Completaremos el cuerpo del método "onClick()".

Este es el código que se ejecutará cuando el usuario haga clic sobre el botón de confirmación. Aquí es donde debemos recuperar el título y cuerpo de la anotación y colocarlos dentro del paquete de datos que devolveremos a la "Activity" que invocó esta "Activity". Si la operación es editar en vez de crear, también deberemos poner la identificación del registro de la anotación.

Creación del paquete donde pondremos el título y cuerpo de la anotación.

Bundle bundle = new Bundle();

bundle.putString(Notepadv2.KEY_TITLE, titleText.getText().toString());
bundle.putString(Notepadv2.KEY_BODY, bodyText.getText().toString());
if (rowId != null) {
bundle.putLong(Notepadv2.KEY_ROW_ID, rowId);
}

Asignar la información de resultado, incluyendo el paquete y resultado final de la operación.

setResult(RESULT_OK, null, bundle);
finish();

El método "setResult()" es usado para asignar el código de retorno, la cadena de información textual y el paqueta de datos que será entregado al "Intent" que invocó a esta "Activity". En este caso suponemos que todo estará bien, asi es que devolvemos "RESULT_OK" como valor del código de retorno. No usaremos la cadena de información textual , por esta razón estamos pasando el valor "null".

El método "finish()" es usado como una señal que la "Activity" ha realizado su tarea (una especia de "return"). Todos los argumentos entregados a "setResul()" van a ser devueltos junto con el control de ejecución.

La siguiente es la declaración de las propiedades utilizadas en el código de esta clase.

private EditText titleText;
private EditText bodyText;
private Long rowId;

El código completo del método "onCreate()" es mostrado a continuación.

@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.note_edit);

titleText = (EditText) findViewById(R.id.title);
bodyText = (EditText) findViewById(R.id.body);

Button confirmButton = (Button) findViewById(R.id.confirm);

rowId = null;
Bundle extras = getIntent().getExtras();
if (extras != null) {
String title = extras.getString(Notepadv2.KEY_TITLE);
String body = extras.getString(Notepadv2.KEY_BODY);
rowId = extras.getLong(Notepadv2.KEY_ROW_ID);

if (title != null) {
titleText.setText(title);
}
if (body != null) {
bodyText.setText(body);
}
}

confirmButton.setOnClickListener(new View.OnClickListener() {

public void onClick(View view) {
Bundle bundle = new Bundle();

bundle.putString(Notepadv2.KEY_TITLE, titleText.getText().toString());
bundle.putString(Notepadv2.KEY_BODY, bodyText.getText().toString());
if (rowId != null) {
bundle.putLong(Notepadv2.KEY_ROW_ID, rowId);
}

setResult(RESULT_OK, null, bundle);
finish();
}

});
}

Paso 12

Finalmente, la nueva "Activity" debe ser declarada en el archivo "Android Manifest".

Antes de que una actividad pueda ser "vista" por Android, esta actividad debe tener su propia entrada en el archivo"AndroidManifest.xml". Esto le entregará al sistema la información necesaria para localizar la actividad y saber que requiere para funcionar.

A continuación se muestra el archivo "AndroidManifest.xml" modificado:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.google.android.demo.notepad2">
<application android:icon="@drawable/icon">
<activity class=".Notepadv2" android:label="@string/app_name">
<intent-filter>
<action android:value="android.intent.action.MAIN" />
<category android:value="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity class=".NoteEdit"/>
</application>
</manifest>

Paso 13

Ejecución de la aplicación.

1. Haz clic con el botón derecho sobre el proyecto "Notepadv2" para abrir el menú de contexto y seleccionar "Run As > Android Application".

Soluciones a problemas

2007-12-09T11:00:00.000-08:00

Soluciones a problemas

En el sitio Android Development Community y Android-Spa Team estoy publicando algunas de las soluciones a problemas que he encontrado mientras desarrollo. Aquí iré creado un índice de referencia hacia esas publicaciones.

Problema:

Al ejecutar mi aplicación apareció el siguiente mensaje de error en la consola de Eclipse (además la aplicación no se ejecutó): [2007-12-09 10:53:03 - p2p-services-01] ActivityManager: Error: Activity class {com.northvortex/com.northvortex.Transmisor} does not exist.

Lee la solución.

Problema:

Este es un proble que se les puede presentar después de la instalación de la última versión del SDK ("android_sdk_windows_m3-rc37a.zip") en Windows. Ninguna de las aplicaciones funcionarán correctamente. Incluso el mismo Android Browser dejará de funcionar y desplegará el siguiente error:

An error has occurred in process com.google.android.browser. Unable to create application com.google.android.browser.Browser: java.lang.NullPointerException.

SOLUCIÓN:

Deben borrar los siguientes archivos:

emulator.cfg
userdata.img

Estos archivo en WINDOWS, están ubicados en:

C:\Documents and Settings\tu-usuario\Local Settings\Application Data\Android

Al parecer, la nueva versión del SDK no es capaz de reconocer correctamente las imágenes que creo la versión anterior del SDK.

NOTA: Al borrar estos archivos perderás los cambios que habías hecho en el emulador (aplicaciones instaladas, etc.)

Esta información también la publiqué aquí.

IMPORTANTE NOTICIA!

2007-12-08T09:40:00.000-08:00

Voy a la competencia de Google Android

Quiero informarles que he decidido participar en el desafío de Google y durante los próximos 2 meses trabajaré en la creación de una aplicación Android que haga uso de las más interesantes características de Android Platform.

Debido a lo anterior además de la traducción de la documentación de Google, tambén comenzaré a publicar mis propias experiencias en el uso de Android y todo el código fuente (bien documentado).

Los documentos que seas de mi creación tendrán el título ¿CÓMO HACER? - tópico

P-e-d-r-o

Observaciones

2007-12-02T15:44:00.000-08:00

Proyectos

Este es un índice con las notas importantes aprendidas en cada ejemplo.

lista-de-contactos

Declaración del permiso para leer información de la lista de contactos.
Cómo leer información de la lista de contactos.
Cómo asociar la declaración de un objeto (en código Java) con un elemento declarado en un layout (main.xml).

comunicacion-xpmm-01

Utilización del protocolo XMPP para mensajería entre dispositivos.
Implementación de la interface OnClickListener. Esta interface define el "Callback" que será invocado como respuesta al evento clic sobre una "View".
Implementación de la interface ServiceConnection. Esta interface define un monitor del estado de una aplicación tipo servicio.
Declaración de un elemento "receiver" en el archivo "AndroidManifest.xml". Esto permite declarar un "IntentReceiver" que reaccione a datos o eventos enviados/gatillados desde una "Activity".
Declaración y uso de un objeto Spinner.

Manos a la obra - Tutorial - Ejercicio #1

2007-12-01T22:40:00.000-08:00

Tutorial: Ejercicio #1

[Título original: Tutorial: Notepad Exercise 1]

Documento original: Tutorial: Notepad Exercise 1

En este ejercicio construiremos una simple lista de anotaciones que permitirá al usuario agregar una nueva nota, pero por ahora no le permitirá editarla. Este ejercicio demostrará:

Conceptos básicos de una "ListActivity". Además, la creación y manipulación de opciones de un menú.

Recuperación y almacenamiento de las notas en una base de datos "SQLite".

Cómo enlazar datos dentro de una "ListView" usando un "ArrayAdapter" (una de las formás más simples de enlazar datos a un "ListView").

Los conceptos básicos de diseño de una pantalla, incluyendo cómo diseñar una lista, cómo agregar elementos al menú de una "Activity" y cómo manipular la selección de esos elementos.

Paso #1

[Título original: Step 1]

Importar el proyecto "Notepadv1" a nuestro "workspace" de Eclipse.

NOTA: "Notepadv1" es un proyecto que provee el punto de partida a este ejercicio y nos ahorrará el tiempo de hacer las cosas que ya aprendiste al desarrollar la aplicación "Hola Mundo".

A continuación están las instrucciones para esta sección:

Dentro del "Package Explorer" haz clic con el botón derecho y selecciona "Import... > General > Existing Projects into Workspace. Luego presiona el botón "Next > ".

A continuación, presiona el botón "Browse" y navega hasta donde extrajiste los directorios de los ejercicios y selecciona "Notepadv1". Finalmente, presiona el botón "OK".

Después del paso anterior deberías ver el elemento "Notepadv1" en la lista de proyectos con una marca de seleccionado al lado de él.

Presiona el botón "Finish".

El proyecto debería haberse abierto en el "Package Explorer" y estar listo para trabajar con él.

Si vieras un error relacionado con el archivo "AndroidManifest.xml", o con un archivo ".zip" de Android, has clic con el botón derecho sobre el proyecto y selecciona desde el menú de contexto "Android Tools > Fix Project Properties".

Paso #2

[Título original: Step 2]

Dale un vistazo a la clase "DBHelper". Esta clase encapsula el acceso y actualización de los datos de nuestras anotaciones almacenadas en una base de datos "SQLite" local en nuestro dispositivo.

Normalmente, el acceso a datos debería ser implementado usando un "ContentProvider", y de hecho la aplicación "Notepad" que está incluida en el SDK (en el directorio "samples/") implamenta un "ContentProvider". Sin embargo, no hay ninguna restricción en utilizar directamente tu propia base de datos tal como lo haremos en este ejercicio. Lo más importante a destacar de la clase "DBHelper" es que toma la responsabilidad de todos los detalles relacionados con el almacenamiento, recuperación y actualización de datos de una base de datos "SQLite". Provee métodos para: (A) recuperar todas los registros, (B) recuperar un registro basado en un "rowIds", (C) crear un nuevo registro, (D) borrar un registro (E) actualizar un registro.

Accesando y modificando datos

[Título original: Accessing and modifying data]

En este ejercicio, vamos a usar directamente una base de datos SQLite para almacenar nuestros datos, pero en una aplicación real sería mucho más conveniente escribir un "ContentProvider" para encapsular este comportamiento.

Si tú estás interesado en aprender más sobre "ContentProvider" o el tema "Almacenamiento, recuperación y exposición de datos".

Paso #3

[Título original: Step 3]

Abre el archivo "notepad_list.xml" que está localizado en "res/layout" y dale un vistazo.

Este archivo contiene la definición del diseño de la pantalla y contiene el punto de inicio para dibujar la pantalla.

Todos los archivos de diseño de pantalla comienzan con un encabezado XML.

Con frecuencia, pero no siempre, la raíz del documento de diseño es una definición del tipo de distribución que tendrán los elementos en la pantalla, en este caso es"LinearLayout".

El "xml namespace" de Android (xmlns:android="http://schemas.android.com/apk/res/android") debería ser siempre definido como un atributo del elemento de mayor jerarquía en el documento de diseño de pantalla, de esa forma el espacio de nombre "android:" podrá ser utilizado por los elementos que estén anidados.

Esquemas y actividades

[Título original: Layouts and activities]

Muchas actividades tendrán un esquema asociado a ellas. El esquema será la "cara" que el usuario verá de la actividad. En este ejemplo, el esquema ocupará completamente la pantalla y proveerá una lista de anotaciones.

Los esquema de pantalla completa no son la única opción para una actividad. Tú también podrías usar un esquema flotante (por ejemplo para un mensaje de alerta) o quizá ni siquiera necesites un esquema (en este caso la actividad es invisible al usuario a menos que quieras asociar un esquema a la actividad).

Paso #4

[Título original: Step 5]

Ahora, necesitamos modificar el diseño de la pantalla para que contenga nuestra lista. Para hacer esto agregaremos dentro de la etiqueta "LinearLayout" las etiquetas "ListView" y "TextView".

El siguiente archivo corresponde a la nueva versión después de realizar las modificaciones:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width="wrap_content"
    android:layout_height="wrap_content">

  <ListView id="@+id/android:list"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
        
  <TextView id="@+id/android:empty"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/no_notes"/>

</LinearLayout>

Los elementos "ListView" y "TextView" pueden ser entendidos como dos vistas alternativas, es decir, en cualquier momento sólo una de ellas será desplegada. El elemento "ListView" será usado sólo cuando tengamos anotaciones para ser mostradas y "TextView" será usado para desplegar el mensaje "No Notes Yet!" cuando aún no tengamos anotaciones para mostrar. (El valor inicial de "TextView" está definido como un recurso de tipo "string").

El caracter "@" en los atributos "id" de "ListView" y "TextView" le indican al "XML parser" que debe reemplazar estos valores por valores definidos en el archivo de recursos o en la "Android platform".

Los textos "android:list" y "android:empty" son identificadores que son proporcionados por la "Android platform". El elemento identificado con "empty" será usado automáticamente cuando no hayan datos para ser desplegados en la lista.

En general, la clase "android.R" es un conjunto predefinido de recursos que la plataforma te provee, por el contrario, la clase "R" de tu proyecto es el conjunto de recursos que tu proyecto a definido. Los recursos que se encuentran definidos en la clase "android.R" pueden ser usados en los archivos XML anteponiendo el espacio de nombre "android:", como se ve en el ejemplo anterior.

Paso #5

[Título original: Step 5]

Para crear una vista con una lista, también debemos definir la vista para cada una de las filas:

Crearemos un nuevo archivo dentro de "res/layout" llamado "notes_row.xml".

Agregarenos el siguiente contenido al archivo:

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

Esta es la vista que será usada para el título de cada anotación. Es sólo un texto.

En este caso, hemos creado un nuevo identificador llamado "text1". El caracter "+" que está a continuación del caracter "@" indica que el identificador deberá ser creado automáticamente si es que no existe, es decir, estamos definiendo "text1" dinámicamente y luego empleándolo.

Después de grabar el archivo, si abrimos el archivo "R.java" deberemos ver una nueva definición para "notes_row" y "text1", lo que significa que ahora tendremos acceso a esos elementos desde nuestro código.

Recursos y la clase "R"

[Título original: Resources and the R class]

En los proyectos Eclipse, los subdirectorios de "res/" son especiales. Hay un estructura específica para los directorios y archivos bajo este directorio.

En particular, los recursos definidos en estos directorios y archivos tendrán sus correspondientes entradas en la clase "R" lo que permitirá que sea muy fácil referenciarlos y usarlos desde tus aplicaciones. Adicionalmente, estos archivos serán empaquetados y distribuidos como parte de tu aplicación.

Paso #6

[Título original: Step 6]

A continuación, abre la clase "Notepadv1"; ya que la vamos a modificar para convertirla en el adaptador de nuestra lista y así desplegar las anotaciones y agregar nuevas.

La clase "Notepadv1" es una subclase de "Activity" llamada "ListActivity", la cual tiene un funcionalidad adicional que es proporcionar todo tipo de operaciones que comúnmente desearíamos realizar con una lista. Por ejemplo, desplegar un número arbitrario de filas en la lista y permitir seleccionarlas.

Dale un vistazo al código de la clase "Notepadv1". Hay algunas definiciones de constantes, seguidas de propiedades privadas y finalmente algunos métodos que sobreescriben métodos de la super clase.

Paso #7

[Título original: Step 7]

Cambia la herencia de "Notepadv1" de "Activity" a "ListActivity":

public class Notepadv1 extends ListActivity

NOTA: Debes importar la clase "ListActivity" en el archivo "Notepadv1". En Eclipse puedes precionar ctrl-shift-O (Windows y Linux).

Paso #8

[Título original: Step 8]

Debemos agregar código a los siguientes métodos: "onCreate", "onCreateOptionsMenu" y "onOptionsItemSelected".

onCreate() es llamado cuando la "Activity" es activada. Es una especie de método "main" en una aplicación "C". Este método es utilizado para definir recursos y estados de la "Activity" que se está ejecutándo.

onCreateOptionsMenu() es usado para poblar el menú de la "Activity". Este menú es mostrado cuando el usuario presiona el botón de menú.

onOptionsItemSelected() es usado para controlar los eventos generados por el menú. Por ejemplo, cuando el usuario selecciona un elemento del menú.

Paso #9

[Título original: Step 9]

A continuación modificaremos el método "onCreate()".

Aquí definiremos el título de la actividad (el título es mostrado en el borde superior de la pantalla). Usaremos el diseño indicado en "notepad_list.xml" para desplegar los contenidos de la actividad. Además, definiremos una instancia de "DBHelper" para tener acceso de los datos de las anotaciones.

Llamamos al método "super.onCreate()" con el parámetro "icicle" que entrega nuestro método.

Llamamos al método "setContentView()" para definir "R.layout.notepad_list" como el esquema que usaremos.

Creamos una propiedad privada llamada "dbHelper", la cual es una instancia de la clase "DBHelper" (esto lo hacemos antes del código del método "onCreate()").

En el método "onCreate()", instanciamos la propiedad "dbHelper" (debemos pasar el valor "this" como argumentos del constructor de la clase "DBHelper").

Finalmente, llamamos al método "fillData()" (será definido más adelante) para llenar nuestra lista con datos.

Él método "onCreate()" debería verse así:

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle)
{
 super.onCreate(icicle);
 setContentView(R.layout.notepad_list);
 dbHelper = new DBHelper(this);
 fillData();
}

Recuerda agregar la definición de la propiedad (justo debajo de la definición de "private int noteNumber = 1;"):

private DBHelper dbHelper;

Paso #10

[Título original: Step 10]

A continuación modificaremos el método "onCreateOptionsMenu()".

Por ahora sólo agregaremos una opción al menú de la aplicación: "Add Item". El texto para esta opción es parte de los recursos de la aplicación y está definido en "strings.xml".

En el archivo "strings.xml" (localizado en "res/values"), agrega una nueva etiqueta para "menu_insert" con el texto "Add Item".

<string name="menu_insert">Add Item</string>

Necesitamos agregar una constante para la posición del menú: public static final int INSERT_ID = Menu.FIRST;

En el método "onCreateOptionsMenu()" agregar el ítem del menú. También nos hacemos cargo del resultado retornado por el llamado del método "super.onCreateOptionsMenu(menu)".

La nueva versión del método debe verse de la siguiente forma:

@Override
public boolean onCreateOptionsMenu(Menu menu) 
{
 boolean result = super.onCreateOptionsMenu(menu);
 menu.add(0, INSERT_ID, R.string.menu_insert);
 return result;
}

Más información sobre menús

[Título original: More on menus]

La aplicación "Notepad" que estamos construyendo sólo muestra la superficie de los menús.

Podemos usar teclas para acelarar el uso de menús, crear submenús e incluso agregrar items de menús a otras aplicaciones.

Paso #11

[Título original: Step 11]

Este método va a responder cuando se seleccione en el menú la opción "Add Note". Cuando la opción sea seleccionada, este método será llamado con el valor de "item.getId()" en "INSERT_ID" (la constante que nosotros definimos para identificar este elemento del menú). Realizaremos las siguientes acciones:

El llamado al método "super.onOptionsItemSelected(item)" va al final del método porque primero nos interesa capturar los eventos.

Codificamos una sentencia "switch" para evaluar "item.getId()".

El "case INSERT_ID:" llama al método "createNote()".

Retornamos el valor devuelto por "super.onOptionsItemSelected(item)".

La nueva versión del método debe verse de la siguiente forma:

@Override
public boolean onOptionsItemSelected(Item item) 
{
 switch (item.getId()) {
 case INSERT_ID:
  createNote();
  fillData();
  break;
 }
 
 return super.onOptionsItemSelected(item);
}

Paso #12

[Título original: Step 12]

Creación del método "createNote()".

En esta primera versión de "createNote()" simplemente crearemos una nueva nota con un título basado en un contador: "Note 1", "Note 2"... y tendrá un cuerpo en blanco. Algunas observaciones sobre el código:

La sentencia: String noteName = "Note " + noteNumber++; es usada para construir el título de la nota.

El llamado a "dbHelper.createRow()" creará la nota usando "noteName" como título y la el texto vacío ("") como cuerpo.

La nueva versión del método debe verse de la siguiente forma:

private void createNote() 
{
 String noteName = "Note " + noteNumber++;
 dbHelper.createRow(noteName, "");
 fillData();
}

Paso #13

[Título original: Step 13]

Creación del método "fillData()".

Este método usa un "ArrayAdapter", el cual es la forma más fácil de poner datos en un "ListView". Un "ArrayAdapter" toma una "List" o un arreglo de "String" y los enlaza a una vista de texto provista en el diseño de una fila de la lista (esto es el campo "text1" de nuestro archivo "notes_row.xml"). Este método simplemente obtiene una lista de anotaciones desde el "database helper" y construye una "List" de "String" usando el título de cada registro y entonces crea un "ArrayAdapter" con todos esos ítems y los asocia con el diseño "notes_row".

Algunas observaciones sobre el ccódigo:

"ArrayAdapter" necesita un "List" conteniendo los ítems a desplegar.

Los datos son recuperados como registros, y el título del registro es utilizado para poblar la lista.

Nosotros indicamos que "notes_row" es la vista que usaremos como receptora de los datos.

Para importar automáticamente las clases utilizadas presiona ctrl-shift-O.

La nueva versión del método debe verse de la siguiente forma:

private void fillData() 
{
 // We need a list of strings for the list items
 List<String> items = new ArrayList<String>();

 // Get all of the rows from the database and create the item list
 List<Row> rows = dbHelper.fetchAllRows();
 for (Row row : rows) 
 {
  items.add(row.title);
 }
 
 // Now create an array adapter and set it to display using our row
 ArrayAdapter<String> notes = new ArrayAdapter<String>(this, R.layout.notes_row, items);
 setListAdapter(notes);     
 
 return;
}

NOTA: En este ejercicio hemos utilizado "ArrayAdapter", pero este objeto no es una solución escalable. Generalmente, "SimpleCursorAdapter" podría ser empleado en combinación con "ContentProvider" o al menos un "Cursor" retornado desde el "query".

Adaptadores de listas

[Título original: List adapters]

Nuestro ejemplo utiliza un adaptador de colección muy simple, el cual asocia una colección o lista de items con una "ListView". En Android es más común que los adaptadores de listas vayan mano a mano con "ContentProviders" y esta es una forma muy fácil de usar listas.

Para asociar un "ContentProvider" con una "ListView" podemos usar un "SimpleCursorAdapter" que asociará los datos desde un "ContentProvider" con una "ListView".

Paso #14

[Título original: Step 14]

Ejecución de la aplicación.

Paso #14

http://2.bp.blogspot.com/__WZr8mbWg3o/R17iAnUfWNI/AAAAAAAAAB0/qKkKGa88g1Q/s320/figura-07.jpg

Solución y próximos pasos

[Título original: Solution and Next Steps]

Puedes ver la solución a este clase en "Notepadv1Solution" para comparar su contenido con el tuyo.

Una vez que estés listo, continúa con el documento Tutorial: Ejercicio #2, en el cual agregaremos la capacidad de crear, editar y borrar anotaciones.

Manos a la obra - Tutorial - Introducción

2007-12-01T20:02:00.000-08:00

Tutorial: Un editor de anotaciones

[Título original: Tutorial: A Notepad Application]

Documento original: Tutorial: A Notepad Application

El tutorial de esta sección te dará la oportunidad de utilizar el "Android framework" y las herramientas necesarias para la construcción de una aplicación. Partiendo desde un proyecto preconfigurado, continuaremos con el proceso de desarrollo de una aplicación en la que tendremos que programar la lógica y diseñar la UI. Finalmente, compilar el código y ejecutar la aplicación.

Para el momento en que hayas terminado el tutorial, tú habrás creado una aplicación Android completamente funcional y además habrás aprendido en profundidad los conceptos más importantes en el desarrollo de una aplicación Android. Si te interesa agregar funcionalidades más complejas a tu aplicación, puedes darle un vistazo al código de ejemplo que es suministrado con el "Android SDK".

¿Quiénes deberían leer este tutorial?

[Título original: Who Should Use this Tutorial]

Este tutorial está concebido para ser utilizado por desarrolladores, especialmente para aquello que tienen conocimiento de Java. Si tú no tienes experiencia escribiendo aplicaciones Java, también puedes utilizar el tutorial pero deberás trabajar un poco más lento.

Este tutorial está basado en la información descrita en los documentos Instalando el SDK y Hola Androide!, los cuales explican en detalle cómo preparar tu entorno de desarrollo para la construcción de aplicaciones Android. Antes de que comiences este tutorial, asegúrate de haber descargado e instalarlo el "SDK" de acuerdo a las instrucciones dadas.

Finalmente, este tutorial describe cómo desarrollar un editor de anotaciones dentro del entorno de desarrollo de Eclipse y con el "Android plugin" instalado. Si tú no estás usando Eclipse, puedes seguir los ejercicios y construir la aplicación, pero tú tendrás que determinar como realizar las instrucciones específicas para Eclipse en tu entorno particular. Si tú quieres agregar características más complejas a tu aplicación, puedes darle un vistazo al código de la aplicación "Notepad" que es suministrada en el área de ejemplos de código del "Android SDK".

El tutorial asume que tú ya estás familiarizado con los conceptos básicos de las aplicaciones Android y su terminología. Si este no es el caso, deberías comenzar a leer Anatomía de una aplicación Android antes de continuar.

Archivos necesarios para los ejercicios

[Título original: Preparing for the Exercises]

Antes de que comencemos, es importante que tú instales y configures el entorno de desarrollo de Eclipse. Una vez que tu entorno esté completamente configurado, ubica el archivo "NotepadCodeLab.zip", el cual es parte de la distribución del SDK y desempaqueta los archivos de los ejercicios. Este archivo contiene una serie de archivos de proyectos Eclipse que serán usados en los ejercicios. Tú puedes usar estos proyectos y archivos para así evitar crear y configurar tus propios archivos de proyectos.

El archivo "NotepadCodeLab.zip" se encuentra en el directorio:

[Android SDK]\docs\intro\codelab

Una vez que ubicaste el archivo, extrae los archivos a un directorio de tu elección (yo lo haré en C:\NotepadCodeLab). Al extraer los archivos deberías ver seis directorios: Notepadv1, Notepadv2, Notepadv3, Notepadv1Solution, Notepadv2Solution y Notepadv3Solution. Los directorios llamados Notepadv* contienen los proyectos que utilizaremos en cada ejercicio, mientras que los directorios llamados "Notepadv*Solution" contienen los archivos correspondientes a la solución final. Las soluciones finales te permitirán detectar errores en caso que tus ejercicios no funciones adecuadamente.

NOTA: El archivo "NotepadCodeLab.zip" también puede ser descargado desde NotepadCodeLab.zip

Descripción de los ejercicios

[Título original: Exercises]

El siguiente listado contiene un breve descripción sobre las áreas que cada ejercicios cubre. Cada ejercicio asume que tú has completado el ejercicio anterior.

Ejercicio #1: Construir un simple lista de notas a la cual el usuario podrá agregar otras, pero no podrás editarlas. Esto demostrará: (a) los conceptos básicos de "ListActivities", (b) la creación y manipulación de opciones de menú y (c) la utilización de una base de datos SQLite para almacenar los datos.

Ejercicio #2: Agregar una segunda "Activity" a la aplicación. Esto demostrará: (a) la construción de una nueva "Activity", (b) modificación del archivo "Android manifest" para agregar la nueva "Activity", (c) paso de datos entre "Activity", (d) diseño más avanzado de pantallas y (e) cómo invocar asincrónicamente otra "Activity" a través de "startSubActivity()".

Ejercicio #3: Agregar a la aplicación un controlador de eventos del ciclo de vida, para así mantener el estado de la aplicación a través de su ciclo de vida.

Ejercicio #4: Demostrará cómo utilizar "Eclipse debugger" para ver los eventos del ciclo de vida de una aplicación en la medida que ellos van siendo generados. Esta sección es opcional, pero altamente recomendable.

Otros recursos para acelarar el aprendizaje

[Título original: Other Resources and Further Learning]

Más revisar algunos detalles no cubiertos en este tutorial, te recomiendo que leer la sección titulada "Tareas comunes en Android".

El "Android SDK" incluye una variedad de ejemplos completamente funcionales que te darán una excelente oportunidad para aprender nuevos conceptos. Estos ejemplos se encuentras en el directorio "[Android SDK]/samples/".

Este tutorial está basado en uno de los ejemplos distribuidos con el SDK. Es altamente recomendable que al final del tutorial revises esa aplicación ya que podrás aprender algunas interesantes caraterísticas, tales como: (a) definición de un lista personalizada para la lista de notas, (b) creación de una "VIEW" personalizada para editar el texto, (c) implementación completa de una "ContentProvider" y (d) revertir y descartar ediciones en vez de grabarlas automáticamente.

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

2007-11-29T15:17:00.000-08:00

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:

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.

Manos a la obra - Hola Androide

2007-11-26T19:19:00.000-08:00

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:

Crea un nuevo "Android Project" seleccionando del menú principal File > New > Project.
Ingresa la información con el detalle del proyecto en el cuadro de diálogo "New Android Project".
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

2007-11-26T13:14:00.000-08:00

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.

Manos a la obra - Introducción

2007-11-20T19:11:00.000-08:00

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.

¿Qué es Android?

2007-11-19T07:46:00.000-08:00

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].

Bienvenido a Android

2007-11-16T15:49:00.000-08:00

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

2007-11-16T15:04:00.000-08:00

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.

Términos técnicos

2007-11-05T11:41:00.000-08:00

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

Referencias

2007-11-01T11:43:00.000-07:00

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.

The Friend Finder - MapActivity using GPS : Este es un buen ejemplo de cómo recuperar las coordenadas del celular y utilizarlas para crear un mapa interactivo.

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.