Blog de SBC

Propositos2012 - Purposes2012

2011-12-29T19:30:00.002+01:00

Escribe y comparte tus propósitos para el año nuevo 2012.

Con esta aplicación podrás escribir tus propósitos u objetivos para el nuevo año. Verás tus progresos a medida que los vayas cumpliendo.
Además, podrás compartir tus propósitos en las redes sociales y ver el hashtag #proposito2012 (en la versión española, #purpose2012 en las demás versiones) de todo el mundo.

Aquí os dejo el enlace del market y algunas capturas.

https://market.android.com/details?id=es.desbc.objectives2012

Espero que os guste!

EuriborRates y CalculaHipoteca

2011-11-30T14:03:00.000+01:00

Ahora puedes comprobar la cuota de tu hipoteca desde la aplicación EuriborRates. En el ActionBar en la parte superior verás el siguiente botón:

que al pulsarlo te llevará a la pantalla que te permitirá calcular la cuota de tu hipoteca. Todos los campos son de escritura libre, pero además en el campo 'interés' se puede rellenar automáticamente con la media del mes actual, o con el valor del último mes ya acabado:

Recuerda que la aplicación se puede encontrar en dos versiones, una gratis y con publicidad (ahora con publicidad en forma de banners -admob- y en mensajes push -AirPush-), y otra de pago por solo 0,50 euros sin publicidad.

https://market.android.com/details?id=es.desbc.donate.euriborrates

https://market.android.com/details?id=es.desbc.euriborrates

Recuerda que toda sugerencia o duda será bienvenida.

Nueva version EuriborRates para Android

2011-10-21T17:43:00.001+02:00

Desde hace unos días está publicada la nueva versión de EuriborRates para Android.

Las nuevas características son:

Nueva interfaz de usuario
Se han añadido más valores y ahora están disponibles los 12 meses y la media del mes actual, en el listado principal.
Widgets de diferentes tamaños

No dudes en probarla, y si te gusta, puedes comprar la versión "donate" por solo 50 céntimos!

Aquí os paso algunas capturas y los enlaces del Market para descargarla.

Versión normal: https://market.android.com/details?id=es.desbc.euriborrates

Donate Version: https://market.android.com/details?id=es.desbc.donate.euriborrates

Hasta los próximos cambios!

Euribor Rates 2 Beta

2011-03-30T11:21:00.001+02:00

Desde hace unas semanas está disponible en el market la versión 2 Beta de EuriborRates. En esta nueva versión se incluyen las siguientes características y mejoras:

Nueva interfaz
Más valores. Ahora se pueden ver los valores de 12, 9, 6 y 3 meses, así como la media mensual
Se puede configurar el widget para mostrar los valores deseados e identificarlos con una cadena de dos carácteres
Se puede visualizar una gráfica por tipo de valor de hasta 50 valores

Para suministrar los datos también se ha migrado a AppEngine.

Estoy pendiente de publicar una nueva versión mejorando el tiempo de carga de la primera ejecución. Para las siguientes versiones tengo pensado las siguientes mejoras:

Añadir más valores
Mejorar la gráfica
Incluir enlace a donaciones
Mejorar la parte del servidor

Os dejo los enlaces y QR del market de las dos versiones (Free y Donate).

Y ya sabéis, SE ACEPTAN SUGERENCIAS.

EuriborRates - Más cambios y Donate Version

2010-08-10T19:19:00.001+02:00

He publicado otra versión de EuriborRates con la siguiente mejora:

Búsqueda de valores publicados desde el año 2000. Funciona seleccionando el mes y el año que queremos buscar. El resultado se muestra en un dialogo de alerta.

Código QR:

Además he publicado una versión de donación por 0,50€. Es igual que la aplicación gratis pero sin publicidad. Se puede buscar directamente en el market o desde el menú de la aplicación gratis. Este es el QR:

Cambios en EuriborRates

2010-08-08T20:53:00.000+02:00

En la versión 1.2 se ha cambiado lo siguiente:

Se puede acceder desde el menú de aplicaciones por si no quieres utilizar el widget
Se ha añadido el valor de media mensual del mes actual
Se ha añadido un menú. Cuando pulsamos en la tecla de menú podemos ver 3 opciones:

Blog: para visitar este blog
Info: podemos ver la información que se muestra la primera vez que instalamos la aplicación
Exit: para salir de la configuración del widget.

Multidioma para inglés y español, dependiendo del idioma del teléfono. Si el idioma no es ninguno de los dos anteriores, el idioma por defecto es el inglés.
Botón de sugerencias
Pequeños cambios en la interfaz gráfica

¿Alguna pregunta o sugerencia?

PD: Parece que la publicidad de AdMob no se muestra siempre, alguien me lo puede confirmar? Gracias

Añadido AdMob a EuriborRates

2010-05-28T00:06:00.001+02:00

A partir de hora, en la pantalla de configuración del widget, aparecerá publicidad en la parte inferior:

La publicidad es de Admob. Es bastante sencillo agregar la publicidad, los pasos explicados a groso modo son:

Tenemos que tener la aplicación ya publicada en el market para obtener un código (publisher id) cuando nos registremos en Admob
Descargarnos la librería Admob y agregarla a nuestro proyecto
Modificar el Manifest utilizando el publisher id
Añadir permisos de conexión a internet si nos tenemos, y opcionalmente de localización
Declarar el estilo de la publicidad (viene dado en el manual) en res/values/attrs.xml
Probar!

Una vez nos registremos e indiquemos cual es nuestra aplicación, podremos acceder a un manual en pdf dónde se explican detalladamente los pasos a seguir.

Ahora, a esperar que la gente pulse en la publicidad ;)

EuriborRates - Primer widget en el Market

2010-05-24T23:58:00.000+02:00

Por fin he publicado en el Market!

Es un widget en el que se puede ver el valor diario del Euribor.

Para todos aquellos que tenemos hipoteca y depende del Euribor, ya podemos ver su valor diario.

Para descargarla:

Espero que os guste. Y no dudéis en dejar comentarios y sugerencias.

GRACIAS

Notepad Tutorial - Ejercicio 2

2010-04-22T18:40:00.097+02:00

Ejercicio 2

En este ejercicio añadiremos una segunda Activity para crear, editar y eliminar notas.

Paso 1

Abrimos el proyecto Notepadv2 en Eclipse. El punto de inicio de este proyecto es la solución del ejercicio 1:

File > New > Android Project
Seleccionamos Create project from existing source
Seleccionamos el directorio Notepadv2 que nos hemos descargado antes
La mayoría de propiedades del proyecto se rellenan automáticamente. Seleccionamos el Target, en Android Labs nos recomiendan seleccionar la versión del sdk menor para que sea compatible con la mayor cantidad de dispositivos.
Pulsamos en Finish

Como veis son los mismo pasos que para el ejercicio 1.

Paso 2

En primer lugar, vamos a crear el menú contextual que permitirá a los usuarios borrar las notas una a una. Miramos la clase Notepadv2.
Para que cada elemento de la lista en el ListView sea accesible desde el menú de contexto, llamamos al método registerForContextMenu() pasándole el ListView:

   registerForContextMenu (getListView ());

Como nuestra Activity hereda de la clase ListActivity, getListView()nos devuelve el objeto local ListView. Ahora, cada elemento del ListView activa el menú contextual.

Ahora completamos el método onCreateContextMenu(), que será similar al menú de opciones. Añadiremos una línea para poder eliminar una nota desde el menú:

   public boolean onCreateContextMenu(Menu menu, View v
   ContextMenuInfo menuInfo) {
   super.onCreateContextMenu(menu, v, menuInfo);
   menu.add(0, DELETE_ID, 0, R.string.menu_delete);
   }

Paso 3

Ahora tenemos que controlar lo que hacemos cuando seleccionamos la opción del menú contextual. El método que tenemos que implementar es:

   public boolean onContextItemSelected(MenuItem item) {
   switch(item.getItemId()) {
   case DELETE_ID:
   AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
   mDbHelper.deleteNote(info.id);
   fillData();
   return true;
   }
   return super.onContextItemSelected(item);
   }
Para saber que ítem tenemos que eliminar lo hacemos con un objeto de tipo AdapterContextMenuInfo, que obtenemos con el método getMenuInfo().

Paso 4

Todavía en la clase Notepadv2 creamos el siguiente método:

   private void createNote() {

   Intent i = new Intent(this, NoteEdit.class);
   startActivityForResult(i, ACTIVITY_CREATE);
   }

El método startActivityForResult() lanza el Intent devolvuendo un valor, en este caso un int.

Paso 5

Rellenamos el método:

   @Override
   protected void onListItemClick(ListView l, View v, int position, long id) {
   super.onListItemClick(l, v, position, id);
   Cursor c = mNotesCursor;
   c.moveToPosition(position);
   Intent i = new Intent(this, NoteEdit.class);
   i.putExtra(NotesDbAdapter.KEY_ROWID, id);
   i.putExtra(NotesDbAdapter.KEY_TITLE, c.getString(
   c.getColumnIndexOrThrow(NotesDbAdapter.KEY_TITLE)));
   i.putExtra(NotesDbAdapter.KEY_BODY, c.getString(
   c.getColumnIndexOrThrow(NotesDbAdapter.KEY_BODY)));
   startActivityForResult(i, ACTIVITY_EDIT);
   }

Este método se invoca cada vez que seleccionamos un elemento de la lista. Con Intent.putExtra() añadimos la información de la nota, para así poderla editar más tarde.

Paso 6

Los métodos anteriores createNote() y onListItemClick() se llaman de manera asíncrona. Para controlar el retorno de la llamada lo haremos sobreescribiendo el método onActivityResult(). Esto lo podemos hacer ya que hemos lanzado el Intent con startActivityForResult().

   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
   super.onActivityResult(requestCode, resultCode, intent);
   Bundle extras = intent.getExtras();
   switch(requestCode) {
   case ACTIVITY_CREATE:
   String title = extras.getString(NotesDbAdapter.KEY_TITLE);
   String body = extras.getString(NotesDbAdapter.KEY_BODY);
   mDbHelper.createNote(title, body);
   fillData();
   break;
   case ACTIVITY_EDIT:
   Long rowId = extras.getLong(NotesDbAdapter.KEY_ROWID);
   if (rowId != null) {
   String editTitle = extras.getString(NotesDbAdapter.KEY_TITLE);
   String editBody = extras.getString(NotesDbAdapter.KEY_BODY);
   mDbHelper.updateNote(rowId, editTitle, editBody);
   }
   fillData();
   break;
   }
   }
   }

Diferenciamos entre la modificación o creación de una nota. En la creación recogemos del Bundle el title y el body, y llamamos a mDbHelper.createNote(). En la modificación primero tenemos que conseguir el Id de la fila, después también conseguimos el title y el body del Bundle y llamamos a mDbHelper.updateNote().

Paso 7

En este paso simplemente echamos un vistazo al fichero note_edit.xml. Es el layout más complejo del ejercicio pero únicamente vemos que de nuevo sólo está layout_weight=1. Este parámetro nos indica la "importancia" o peso del elemento en la vista. Por defecto el valor es 0.
Este es el layout de la pantalla de edición de una nota.

Paso 8

Para poder la pantalla de edición de las notas, creamos un clase que llamamos NoteEdit que herede de Activity y sobreescribimos el método onCreate(Bundle):

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

   mTitleText = (EditText) findViewById(R.id.title);
   mBodyText = (EditText) findViewById(R.id.body);

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

   mRowId = null;
   Bundle extras = getIntent().getExtras();
   if (extras != null) {
   String title = extras.getString(NotesDbAdapter.KEY_TITLE);
   String body = extras.getString(NotesDbAdapter.KEY_BODY);
   mRowId = extras.getLong(NotesDbAdapter.KEY_ROWID);

   if (title != null) {
   mTitleText.setText(title);
   }
   if (body != null) {
   mBodyText.setText(body);
   }
   }

   confirmButton.setOnClickListener(new View.OnClickListener() {

   public void onClick(View view) {
   // TODO
   }

   });
   }

Paso 9
Ahora completamos el método onClick() que nos faltaba por rellenar:

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

   bundle.putString(NotesDbAdapter.KEY_TITLE, mTitleText.getText().toString());
   bundle.putString(NotesDbAdapter.KEY_BODY, mBodyText.getText().toString());
   if (mRowId != null) {
   bundle.putLong(NotesDbAdapter.KEY_ROWID, mRowId);
   }

   Intent mIntent = new Intent();
   mIntent.putExtras(bundle);
   setResult(RESULT_OK, mIntent);
   finish();
   }

Paso 10

El último paso es añadir nuestra Activity al AndroidManifest.xml para que la Activity sea visible para Android:

Doble click en el fichero AndroidManifest.xml para abrirlo.

Click en la pestaña Application del editor de Manifest.

En la sección Application Nodes pulsamos en Add...

Nos aseguramos que tenemos seleccionado Activity y click en OK.

De nuevo en la sección Application Nodes pulsamos en la nueva Activity, y a la derecha escribimos .NoteEdit en el campo Name*. Pulsamos Intro.

También podemos añadirlo manualmente en el fichero AndroidManifest.xml de la siguiente manera:
   <activity android:name=".NoteEdit"></activity>

Y a correr!

Notepad Tutorial - Ejercicio 1

2010-03-23T21:33:00.001+01:00

En Android Labs nos proponen un tutorial bastante completo, Notepad Tutorial, un gestor de notas.

El tutorial se sigue en forma de ejercicios, 3 más uno extra. De cada ejercicio tenemos un código base y su solución por si tenemos algún problema.

Nos descargamos el código base y las soluciones, y nos preparamos el entorno para empezar con el ejercicio 1.

Ejercicio 1

En este ejercicio 1 construiremos una lista de notas a la que podremos añadir nuevas notas, pero no editaralas.

Paso 1

Abrimos el proyecto Notepadv1 en Eclipse. Este proyecto es el punto de inicio para el ejercicio 1.

File > New > Android Project
Seleccionamos Create project from existing source
Seleccionamos el directorio Notepadv1 que nos hemos descargado antes
La mayoría de propiedades del proyecto se rellenan automáticamente. Seleccionamos el Target, en Android Labs nos recomiendan seleccionar la versión del sdk menor para que sea compatible con la mayor cantidad de dispositivos.
Pulsamos en Finish

Yo no he tenido problemas, pero si en vuestro caso tenéis algún problema con el AndroidManifest.xml, con el botón derecho en el proyecto seleccionamos Android Tools > Fix Project Properties, para que dejen de salirnos.

Paso 2

Echamos un vistazo a la clase NotesDbAdapter, que nos servira para acceder a la base de datos SQLite que utilizaremos para guardar las notas.

Al principio de la clase tenemos unas cuantas constantes declaradas:

   private static final String DATABASE_CREATE =
   "create table notes (_id integer primary key autoincrement, "
   + "title text not null, body text not null);";

Esta es la consulta que crea la tabla de notas, que contiene 3 campos, _id, title y body, de los que también tenemos sus constantes:

public static final String KEY_TITLE = "title";
   public static final String KEY_BODY = "body";
   public static final String KEY_ROWID = "_id";

También tenemos una constante que identifica la clase a la hora de escribir en log:

private static final String TAG = "NotesDbAdapter";

El constructor de la clase NotesDbAdapter toma como parámetro un objeto de clase Context. Esto es para poder acceder a propiedades y métodos del sistema (Android).

En el método open() creamos un instancia de la clase DatabaseHelper, que es un clase local que implementa SQLiteOpenHelper. Con el método getWritableDatabase() obtenemos la base de datos.

Con el método close() simplemente cerramos la conexión con la base de datos.

Al método createNote() le pasamos un String title y otro body para crear una nueva nota en la base de datos. Si se crea bien, devolveremos un long que sera el _id del nuevo registro creado en la tabla.

Con deleteNote() podemos eliminar un registro de la tabla pasándole el _id.

Para obtener todos los registros de la tabla usaremos fetchAllNotes(). Este método nos retorna un Cursor (según Android Labs el sistema es más eficiente que con collections). Dentro del método llamamos a SQLiteDatabase.query() con los parámetros: nombre de la tabla (String), columnas que queremos recuperar (array de Strings, y otros campos que dejamos a null para obtener todos los datos sin agrupar, ni ordernar. (Ver detalles en SQLiteDatabase).

fetchNote() funciona de una forma similar que fetchAllNotes(), pero le pasamos un _id para obtener un registro determinado.

Para actualizar un nota utilizaremos updateNote(), al que le pasaremos _id de la nota que modificar, y los valores actualizados.

Paso 3

Abrimos el fichero res/layout/notepad_list.xml y vemos un LinearLayout vacío. Si alguien no identifica o conoce algo que se pase por HelloLinearLayout.

Paso 4
.
Copiamos el siguiente cógido en res/layout/notepad_list.xml para crear la vista del listado de notas

<?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 android:id="@android:id/list"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<TextView android:id="@android:id/empty"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/no_notes"/>
</LinearLayout>

Es una vista bastante sencilla, en la que tenemos un ListView y un TextView. Suponiendo que ya conocemos un poco de vistas (si no, mirar HelloLinearLayout), lo importante son los id de estos dos elementos. Vemos que empiezan los dos por @android:id/, esto quiere decir que nos lo proporciona la plataforma Android. Pues usaremos 'automáticamente' @android:id/list cuando tengamos notas y @android:id/empty cuando no haya notas.

Paso 5

Para cada fila o item de la lista también deberemos generar una vista. Creamos un fichero nuevo en res/layout y lo llamamos notes_row.xml. El contenido será:

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

Podemos observar que en el id tenemos los carácteres @+. El + indica que los elementos que usan esta vista se generan dinámicamente y el id se creará automáticamente si todavía no existe.

Paso 6

Abrimos la clase Notepadv1 y le cambiamos la clase padre Activity por ListActivity. Esta clase añade funcionalidad extra para trabajar con listas.

Si miramos el código vemos que tenemos un atributo mNoteNumber que todavía no usamos, pero que haremos servir para numerar las notas.

También vemos que sobreescribimos tres métodos:

onCreate: llamado cuando la Activity empieza. Una especie de main
onCreateOptionsMenu: llamado cuando el usuario pulsa en botón de menu
onOptionsItemSelected: cuando pulsamos en el botón de menú, normalmente lanzamos una lista de acciones, como por ejemplo "Crear Nota". Pues este método es llamado cuando el usuario pulsa en una opción de estas.

Paso 7

El método onCreate() debe quedarnos así:

@Override
   public void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.notepad_list);
   mDbHelper = new NotesDbAdapter(this);
   mDbHelper.open();
   fillData();
   }

Después de las dos líneas típicas de un onCreate() (super.onCreate() y setContenView()), creamos la instancia del NotesDbAdapter, al que le pasamos el context. Abrimos la conexión y rellenamos los datos con fillData(), método que todavía no hemos implementado.

Paso 8

En el método onCreateOptionsMenu() copiamos:

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

Para que el código compile debemos añadir en el res/value/strings.xml:

Add Item

Y añadimos en la clase Notepadv1 la siguiente constante:

public static final int INSERT_ID = Menu.FIRST;

De esta manera hemos añadido un botón ("Add Item") que aparecerá cuando pulsemos en el botón de menú del dispositivo.

Paso 9

En onOptionsItemSelected() copiamos:

@Override
   public boolean onOptionsItemSelected(MenuItem item) {
   switch (item.getItemId()) {
   case INSERT_ID:
   createNote();
   return true;
   }

   return super.onOptionsItemSelected(item);
   }

Este método se ejecutará cuando pulsemos en un opción del menú. Recibe como parámetros un MenuItem, el cuál comprobamos si es la primera opción ("Add Note") para crear una nota nueva con createNote(). Finalmente llamaremos al método de la superclase con super.onOptionsItemSelected().

Paso 10

Para este ejercicio 1 implementaremos un versión poco útil del método createNote(). Simplemente crearemos una nota nueva vacía asignándole un titulo incluyendo un contador. La nota no se podrá modificar de momento.

private void createNote() {
   String noteName = "Note " + mNoteNumber++;
   mDbHelper.createNote(noteName, "");
   fillData();
   }

Paso 11

Por último tenemos que implementar el método fillData(). El código es:

private void fillData() {
   Cursor c = mDbHelper.fetchAllNotes();
   startManagingCursor(c);

   String[] from = new String[] { NotesDbAdapter.KEY_TITLE };
   int[] to = new int[] { R.id.text1 };

   SimpleCursorAdapter notes =
   new SimpleCursorAdapter(this, R.layout.notes_row, c, from, to);
   setListAdapter(notes);
   }

Para rellenar los datos usamos un SimpleCursorAdapter. Cuando creamos un objeto SimpleCursorAdapter le pasamos los siguientes parámetros:

this --> Contexto
int layout --> identificador del layout que contiene la lista de elementos a rellenar
Cursor --> Cursor de la base de datos
String[] --> Array de las columnas a rellenar
int[] --> Array de las vistas/layouts que mostrarán los datos

Para poder trabajar con el cursor, la clase Activity nos da el método startManagingCursor(Cursor c).

Paso 12

Ejecutamos la aplicación

Hacer capturas con Nexus One en Ubuntu

2010-03-15T00:00:00.001+01:00

Por Internet existen muchas páginas con las instrucciones que hay que seguir para poder realizar capturas de pantalla, o debuggar, con tu teléfono. Pero después de seguir las instrucciones de varias páginas, yo no lo conseguía para mi Nexus One y Ubuntu.
Pero por fin he encontrado el cómo y voy a explicarlo (fuente).

En un terminal linux ejecutamos lsusb y obtendremos un pantalla del estilo a ésta:

Conectamos el N1 al ordenador y lo ponemos en modo Depuración USB. Ajustes -- Aplicaciones -- Desarrollo -- Depuración USB

En un terminal de linux volvemos a ejecutar lsusb y podremos que se ha añadido un dispositivo a la lista:

Ahora necesitamos crear una regla para nuestro dispositivo. Tenemos que crear un fichero en /etc/udev/rules.d/. Por ejemplo:

El contenido del fichero tiene que ser en mi caso (en negrita los valores que vemos con lsusb):

SUBSYSTEM=="usb", ATTRS{idVendor}=="18d1", ATTRS{idProduct}=="4e12", MODE="0666"

Le damos permisos de acceso y ejecución a ese fichero:

sudo chmod a+rx /etc/udev/rules.d/51.android.rules
Recargamos el servicio udev:

sudo service udev reload
Ahora si arrancamos el servicio adb vemos que no tenemos permisos (imágen de la fuente):

Ahora reiniciamos el servidor. Primero hacemos el kill-server y después (imágen de la fuente):

Por último listamos los dispositivos y veremos algo al estilo:

A partir de ahora podremos hacer capturas y debuggar desde Eclipse:

O desde Dalvik Debug Monitor que ejecutamos con /tools/ddms:

Enviar e-mail con datos predefinidos (con Intents)

2010-03-13T00:00:00.000+01:00

Puede que desde nuestra aplicación queramos enviar un email, ya sea para que el usuario se ponga en contacto con nosotros, con algún negocio, etcétera. En este post voy explicar como hacerlo con Intents.

// Creamos el Intent pasando un String
final Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);

// Rellenamos los datos que queremos predefinir
emailIntent.setType("plain/text");
emailIntent.putExtra(android.content.Intent.EXTRA_EMAIL, new String[]{"sergi.bc@gmail.com"});
emailIntent.putExtra(android.content.Intent.EXTRA_SUBJECT, "DeSBC");
emailIntent.putExtra(android.content.Intent.EXTRA_TEXT, "Gracias SBC");

// Empezamos la acción con createChooser
context.startActivity(Intent.createChooser(emailIntent, "Send mail..."));

En la primera línea creamos un Intent al que le pasamos un String con la acción android.content.Intent.ACTION_SEND. Esta acción permite al usuario enviar información a otra persona, aunque todavía no está definido el como.

En las siguientes 4 líneas estamos completando la información que por defecto queremos enviar, para que cada vez que ejecutemos esta acción siempre sea la misma.

setType("plain/text"): indicamos que el contenido es de tipo plano
android.content.Intent.EXTRA_EMAIL: indicamos un String[] con las direcciones destino
android.content.Intent.EXTRA_SUBJECT: indicamos un String con el asunto del email
android.content.Intent.EXTRA_TEXT: indicamos un String con el contenido del email

El método Intent.putExtra(String, Bundle) añade información extra al Intent. También es posible eliminar información con Intent.removeExtra(String) y recuperar todo el Bundle con Intent.getBundleExtra(String).

En la última línea, con Intent.createChooser(Intent, String), estamos creando un Intent de tipo ACTION_CHOOSER. Se utiliza este método por convención en vez de crearlo de la manera habitual (new Intent(...)). Lo que conseguimos es lanzar una pantalla en la que podemos elegir una Activity, que en nuestro caso será la Activity encarga de enviar el email. Esta puede ser la Activity de gmail o de cualquier otra que sea capaz de enviar emails.

Guardar preferencias

2010-03-12T00:00:00.002+01:00

Cuando queremos que nuestra aplicación tenga unas preferencias o propiedades, tanto fijas o variables, y que se mantengan cada vez que la ejecutamos, podemos almacenar estos valores de varias formas ( Preferences, Files, Databases, y Network)

Quizás la forma más fácil y ligera es con Preferences, que es apropiada para guardar datos de tipo primitivo. La manera de guardar y recoger propiedades es del tipo clave-valor.

Incluso, es posible compartir las preferencias de nuestra aplicación con otras aplicaciones. Aunque si solamente tenemos una aplicación, o no queremos que las preferencias sean compartidas, todavía es más sencillo (el ejemplo que voy a explicar es de este tipo).

El objeto que contiene las propiedades clave-valor es del tipo SharedPreferences, que obtenemos con la llamada Activity.getPreferences(int mode).

Para guardar los cambios de nuestras propiedades usaremos un editor SharedPreferences.Editor, pero para leerlas lo haremos directamente del SharedPreferences.

Vamos con el código de ejemplo (el siguiente código no compila, es solo un trozo de código),

import android.app.Activity;
import android.content.SharedPreferences;

   public class MyActivity extends Activity {

. . .
// En la primera llamada de la Activity recuperamos el valor de una propiedad llamada "welcomeMessage"
@Override
protected void onCreate(Bundle state){
super.onCreate(state);

     // Creamos el objeto SharedPreferences
SharedPreferences settings = getSharedPreferences(MODE_PRIVATE);
// defaultMessage será el valor por defecto de nuestra propiedad
String defaultMessage = "Hola SBC";
   // recuperamos el valor de nuestra propiedad 'welcomeMessage'
String welcomeMessage = settings.getString("welcomeMessage", defaultMessage );
myObject.setWelcomeMessage(welcomeMessage);
}

// Guardaremos las opciones en este evento, pero podríamos hacerlo en cualquier momento
@Override
protected void onStop(){
super.onStop();

// Creamos el objecto SharedPreferences
SharedPreferences settings = getSharedPreferences(MODE_PRIVATE);
     // Recuperamos el editor para poder guardar
SharedPreferences.Editor editor = settings.edit();
// Recuperamos el mensaje que hemos introducido
EditText tv = (EditText) findViewById(R.id.message);
String message = tv.toString();
   // Con el editor le asignamos un valor a nuestra propiedad 'welcomeMessage'
editor.putString("welcomeMessage", message);

// El commit IMPORTANTE sobre el editor
editor.commit();
}
}

Como se puede observar es bastante sencillo. Para poder compartir las preferencias con otras aplicaciones es muy similar, pero en vez de llamar a Activity.getPreferences(int mode), deberemos llamar a Context.getSharedPrefences(String my_preferences, int mode), donde mode my_preferences es el nombre identificativo.

Application Fundamentals I

2010-03-11T00:00:00.001+01:00

Como dije hace unos días, voy intentar resumir el articulo Application Fundamentals de Android Labs. Lo haré en dos partes.

Supongo que a estas alturas ya sabéis que el lenguaje de programación utilizado es Java. Así que para los que estamos familiarizados con este lenguaje, en principio no tendremos grandes problemas para empezar a programar en Android. Para los que no, quizás es recomendable empezar con algún tutorial de Java.

El código java compilado y los recursos utilizados en nuestra aplicación se empaquetan en un fichero de extensión APK (Android Package).

Este fichero APK lo podemos considerar como una aplicación, ya que por cada aplicación tenemos un fichero APK. Para instalarnos una aplicación debemos obtener su fichero APK, ya sea a través del Android Market o de algún otro medio.(Sí, es posible y legal)

Aunque el lenguaje de programación sea Java, las aplicaciones Android no trabajan de la misma manera. Gracias a la DalvikVM una aplicación tiene estas características:

Cada aplicación corre en un único proceso Linux.
Cada proceso corre en una VM.
Cada proceso es asignado a un único User ID.

Nota: este es el comportamiento normal, pero es posible que dos aplicaciones compartan el mismo UserID para ver los ficheros entre ellas. Y también correr en el mismo proceso compartiendo la misma VM.

Application Components

Activities: una Activity es una IU que realiza una actividad o acción. Una aplicación puede tener una simple Activity o varias. Por ejemplo, podemos tener una Activity que liste mensajes, otra que nos permita escribirlos, etc.. Todas estas acciones son clases que heredan de la clase Activity.
Services: es una acción sin IU pero que corre en modo background durante un tiempo indefinido. Por ejemplo, en una aplicación para escuchar música, probablemente tendremos una IU para escoger la(s) canción(es) que queremos escuchar, esto sería una Activity. En cambio, lo que es la reproducción de música en sí será un servicio, ya que si hacemos ostras cosas, como navegar, consultar el correo, etcétera, queremos seguir escuchando la música. Todas las clases que implementan servicios heredan de Service.
Broadcast Receivers: es un componente que aparentemente no hace nada, pero que recibe y reacciona a algunos eventos. Por ejemplo, cuando la batería esta baja, cambiamos de zona horaria, recibimos un mensaje (como en la imagen), etc.. Los broadcast receivers no tienen IU, pero suelen lanzar una Activity o un notificación a través del NotificationManager .Cada clase hereda de BrodcastReceiver.

Content Provieders: los Content Providers hacen posible que cierta información de nuestra aplicación, sea accesible desde otras aplicaciones. Los datos podemos almacenarlos en sistema de ficheros con SQLite u otros medios. Nuestras clases Content Providers heredan de ContentProvider, y tendremos un conjunto de métodos con los que conseguir los datos que nos interesen. Un ContentProvider se activa cuando lo reclama un ContentResolver.

Intents

Los componentes Activity, BrodcastReceiver y Service se activan a través de unos mensajes asíncronos llamados Intents. Nuestros Intents heredan de la clase Intent y contienen el mensaje. A cada tipo componente se le llama de una manera distinta, pasándole la URI (entre otros parámetros):

Activity: Context.startActivity() o Activity.startActivityForResult(). El primer método simplemente lanza la acción, y el segundo espera una respuesta.
Service: Context.startService()
BrodcastReceiver: Varias formas --> Context.sendBroadcast(),Context.sendOrderedBroadcast(), y Context.sendStickyBroadcast()

Manifest

Para que Android pueda iniciar un componente de una aplicación debemos definirlo en un archivo xml. Este archivo se llama AndroidManifest.xml, y estará incluido en el paquete APK junto con los demás recursos.

Además de declarar los componentes, en este fichero también tenemos que incluir las bibliotecas que necesita la aplicación, y también determinar los permisos que el usuario deberá otorgar a la aplicación para su correcto funcionamiento.

Un ejemplo:

<?xml version="1.0" encoding="utf-8"?>

<manifest . . . >

<application . . . >

<activity android:name="com.example.project.FreneticActivity"

android:icon="@drawable/small_pic.png"

android:label="@string/freneticLabel"

. . . >

</activity>

. . .

</application>

</manifest>

En el atributo de name de la <activity> tenemos la subclase de Activity que implimenta la funcionalidad. El icon (icono) y la label (etiqueta) apuntan a los ficheros del directorio de recursos /res/drawable que contiene un icono y una etiqueta.

Los demás componentes (<service>, <receiver>, <provider>) se declaran de una forma similar. Los componentes que no se declaran en el AndroidManifest.xml nunca se podrán ejecutar porque no son visibles para la aplicación. Sin embargo, los <broadcastReceiver> pueden ser declarados tanto en el AndroidManifest como en hardcode. Para ello deberán registrarse con la llamada Context.registerReceiver().

Esta mini-introducción del AndroidManifest.xml se puede completar con The AndroidManifest.xml File.

Intent Filters

Un objecto Intent puede llamar explícitamente a un componente. Gracias al AndroidManifest.xml, Android lo puede encontrará y lo activará. Pero si la llamada no es explícita, Android debe localizar el componente que mejor corresponda a la llamada. Android consigue hacer esto gracias a los IntentFilters. Un IntentFilter le indica a Android cual es el mejor handler para ese tipo de componente. Cosa que también declararemos en el AndroidManifest.xml. Completando el ejemplo anterior:

<?xml version="1.0" encoding="utf-8"?>

<manifest . . . >

<application . . . >

<activity android:name="com.example.project.FreneticActivity"

android:icon="@drawable/small_pic.png"

android:label="@string/freneticLabel"

. . . >

<intent-filter . . . >

<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>

<intent-filter . . . >

<action android:name="com.example.project.BOUNCE" />

<data android:mimeType="image/jpeg" />

<category android:name="android.intent.category.DEFAULT" />

</intent-filter>

</activity>

. . .

</application>

</manifest>

El primer <intent-filter> del ejemplo (la combinación de "android.intent.action.MAIN" y "android.intent.category.LAUNCHER") es muy común, ya que indica que esta Activity es el punto de entrada de la aplicación y que se mostrará en el menú de aplicaciones que puede ejecutar el usuario.

En el segundo <intent-filter> se declara una Activity que podrá manejar datos de tipo image/jpg. "android.intent.category.DEFAULT" es la category que pondremos cuando nuestra Activity no sea ninguna otra específica.

Un componente puede tener cualquier número de IntentFilter. Si no tienen ninguno puede ser activado solamente cuando se llame explícitamente desde el código.

Para completar esta info Intents and Intent Filters.

Hello Views VI

2010-03-09T14:42:00.002+01:00

List View

Para crear una lista de elementos scrollables utilizaremos ListView. Estos elementos se insertarán automáticamente en la lista usando un ListAdapter.

En el ejemplo que nos proponen en Android Labs, veremos una lista de países que leeremos de un array de strings. Cuando seleccionemos un elemento, un Toast se mostrará diciéndonos su posición en la lista.

Los pasos resumidos son:

Crear el proyecto con Eclipse indicando la Activity HelloListView
Crear un fichero llamado list_item.xml y copiar el contenido en el directorio res/layout/. Es el layout para cada elemento de la lista.
Modificar la clase padre de HelloListView. Ahora tiene que heredar de ListActivity
Rellenar el método onCreate()
Copiar el array de paises (o lo que queramos listar)
Ejecutar la aplicación

Ahora vamos comentar los puntos más importantes del ejemplo.

Podemos ver que list_item.xml simplemente nos dice que cada elemento de la lista será una TextView. Aquí podríamos añadir por ejemplo una imagen al lado del texto.
¿Porqué heredamos de ListActivity? Pues porque un ListActivity nos permite mostrar una lista de elementos vinculados a un data source, como un array. Además permite eventos sobre los elementos de la lista.
En el método onCreate() vemos cosas interesantes. Por ejemplo, que no cargamos ningún fichero de layout. En vez de esto, indicamos un ListAdapter con setListAdapter(ListAdapter), que añade automáticamente un ListView que rellena toda la pantalla de la ListActivity.
Al setListAdapter(ListAdapter) le pasamos como parámetros un ArrayAdapter. Para construir este objeto tenemos que pasarle el contexto (en nuestro caso con el this), el layout que utilizaremos para mostrar los elements (list_item.xml), y el array o lista de objecto que queremos mostrar (los países).
El método setTextFilterEnabled(boolean) de la ListView hace posible que podamos filtrar el listado.
El método setOnItemClickListener(OnItemClickListener) define un onClick listener para cada elemento, como vimos en el HelloGridView.
La manera de definir el array de strings, en hardcode, no es la mejor. Para hacerlo de una manera más elegante y práctica es mejor referenciarlo desde un fichero externo. El array deberemos declararlo de la siguiente forma, y ubicándolo el fichero strings.xml en el directorio res/values:

<?xml version="1.0" encoding="utf-8"?>
<resources>
<string-array name="countries_array">
<item>Bahrain</item>
<item>Bangladesh</item>
<item>Barbados</item>
<item>Belarus</item>
<item>Belgium</item>
<item>Belize</item>
<item>Benin</item>
</string-array>
</resources>

Ahora para cargar el ListAdapter tenemos que pasar el array de strings de la siguiente forma:

String[] countries = getResources().getStringArray(R.array.countries_array);

setAdapter(new ArrayAdapter(this, R.layout.list_item, countries));

Dudas
Me surge la duda de si el método setTextFilterEnabled(boolean) sólo funciona cuando nuestros elementos son TextView, o siempre aunque sean de otro tipo y el filtro se haga por algún identificador o descripción.

Notas
Como nos indica Android Labs en el ejemplo, android ya proporciona unos layouts de serie, cosa que no conocía hasta ahora. Os dejo el enlace.

Hello Views V

2010-03-06T00:34:00.004+01:00

TabLayout

Como nos dicen en Android Labs, para crear una interfaz con pestañas o tabs, necesitaremos usar un TabHost y un TabWidget. El TabHost será el nodo raíz de nuestro layout, que tendrá el TabWidget para mostrar las pestañas, y un FrameLayout para enseñar el contenido de las pestañas.

Existen dos formas de implementar un IU con pestañas: en una sola Activity o en una Activity por pestaña. Este último método es el más indicado ya que tendremos separadas las funcionalidades, y lo utilizaremos para este ejemplo.

Los pasos resumidos son:

Crear el proyecto con Eclipse indicando la Activity HelloTabWidget
Crear 3 Activity's más: ArtistsActivity, AlbumsActivity y SongsActivity. Poniendo en cada método onCreate de las 3 Activity un TextView identificativo
Para cada pestaña necesitamos dos imágenes, una para cuando está activada y otra para cuando no (en la página de Android Labs sólo vemos la imagen del micro, podemos coger otras para realizar el ejemplo). Además necesitamos un fichero XML, que hace de selector para realizar precisamente esa acción. Tanto las imágenes como los ficheros XML se guardan en res/drawable
Crear o copiar el contenido del fichero main.xml
Modificar la Activity principal, HelloTabWidget, para que herede de TabActivity en vez de Activity
Copiar todo el código del método onCreate
Cambiar el tema de la aplicación
Ejecutar aplicación

Los puntos clave de este ejemplo (bajo mi punto de vista) son:

El selector: La manera de mostrar una imagen para cuando la pestaña está activa o no se realiza en un fichero XML, y un fichero por Activity. El tag es <selector> y dentro muestra los items que puede mostrar. Con el atributo android:state_selected="true" indicamos cuál es la imagen/item a mostrar cuando la pestaña está activa. Este recurso (fichero XML), se lo tenemos que pasar al método setIndicator a cada Tab.

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
   
   <item android:drawable="@drawable/ic_tab_artists_grey" android:state_selected="true" />
   
   <item android:drawable="@drawable/ic_tab_artists_white" />
</selector>

main.xml: Vemos que la vista empieza y acaba por con el TabHost. Después de indicar el xmlns, id y forma de relleno, vemos un LinearLayout. Dentro de ésto vemos lo importante, un TabWidget y un FrameLayout. El TabWidget ocupa a lo ancho el mismo espacio que su parent, y a lo alto el espacio necesario para mostrarse entero, es decir, el tamaño de la imagen.
onCreate: Conseguimos los recursos, el TabHost con getTabHost (método específico de la clase TabActivity). Creamos un TabHost.TabSpec, que sirve para indicar las propiedades de una pestaña. Esta variable la vamos reutilizando una vez añadimos una pestaña al TabHost con addTab(spec).
Themes: En el ejemplo lo único que hace este tema es no mostrar el título de la aplicación. Pero se pueden hacer muchísimas más cosas. Más info aquí.

Notas

En el código del ejemplo hay un fallo, en el método onCreate indica mTabHost.addTab(spec); cuando quiere decir tabHost.addTab(spec);.
No os olvidéis de cada pestaña tiene dos imágenes y un XML (selector), y que desde el XML se hace referencia al recurso de la imagen (<item android:drawable="@drawable/nombre_imagen"/>). Y que todo va dentro del directorio res/drawable/.
Y tampoco os olvidéis de incluir las 3 Activity en el fichero main.xml.

Hello Views IV

2010-03-04T15:09:00.000+01:00

GridView

Un GridView también es un ViewGroup, que muestra sus hijos en una grid scrollable de manera bidimensional. A diferencia de las otras vistas, los elementos no se van añadiendo en el main.xml, sino que lo hacen a través de un ListAdapter.

En el ejemplo de AndroidLabs nos enseñan a crear una GridView con imágenes en miniatura. Los pasos que tenemos que seguir, y que luego explicaré, son los siguientes:

Crear el proyecto con Eclipse indicando la Activity HelloGridView.
Copiar las imágenes que queremos visualizar en res/drawable (las del ejemplo son estas
Crear o copiar el contenido del fichero main.xml
Crear y copiar el contenido de la clase ImageAdapter, que hereda de la clase BaseAdapter
Copiar el siguiente texto en el método onCreate de la Activity:

   super.onCreate(savedInstanceState);
   setContentView(R.layout.main);

   GridView gridview = (GridView) findViewById(R.id.gridview);
   gridview.setAdapter(new ImageAdapter(this));

   gridview.setOnItemClickListener(new OnItemClickListener() {
   public void onItemClick(AdapterView parent, View v, int position, long id) {
   Toast.makeText(HelloGridView.this, "" + position, Toast.LENGTH_SHORT).show();
   }
   });

En este caso lo más importante no es el main.xml, pero que también voy a comentar:

android:columnWidth: ancho de la columna
android:numColumns: número de columnas. (auto-fit, se ajusta automáticamente)
android:verticalSpacing: separación vertical entre elementos
android:horizontalSpacing: separación horizontal entre elementos
android:stretchMode: forma de estirar el contenido. columnWidth, a lo ancho de la columna

La 'chicha' empieza en el método onCreate de la Activity:

GridView gridview = (GridView) findViewById(R.id.gridview);
gridview.setAdapter(new ImageAdapter(this));

Obtenemos el id de nuestra vista, la grid. Hemos indicado ese id en el fichero main.xml, cuando hemos creado el GridView.

gridview.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView parent, View v, int position, long id) {
Toast.makeText(HelloGridView.this, "" + position, Toast.LENGTH_SHORT).show();
}
});

Añadimos un Listener para cuando hacemos click en el item, una imagen. Al pulsar mostramos un Toast (especie de popup) en el que vemos la posicion de la imagen.

Por último encontramos la clase ImageAdapter, que hereda de la clase BaseAdapter. El método importante es getView(). Este método esta sobreescribiendo al método de la clase Adapter, de la que hereda BaseAdapter, y es llamado cada vez que se va a pintar un elemento de la GridView. En nuestro caso carga las imágenes que hemos descargado antes, y en el orden que le indicamos en el array mThumbIds.

Dudas
Creo que el parámetro convertView viene a null la primera vez que cargamos la GridView, pero en las siguientes llamadas nos viene ya la ImageView. Por eso comprobamos si viene a null o no. ¿Me equivoco?

Hello Views III

2010-03-04T09:01:00.003+01:00

TableLayout
Como las anteriores vistas, la clase TableLayout es una ViewGroup que muestra sus hijos (Views), en filas y columnas. Y también empezamos del mismo modo:

Crear el proyecto con Eclipse indicando la Activity HelloTableLayout.
Crear o copiar el contenido del fichero main.xml.
Cargar la vista en el método onCreate de nuestra Activity.
Ejecutar

Podemos ver dos tablas, que se identifican por el tag TableLayout, y en este caso los atributos importantes son los siguientes:

android:stretchColumns: el número de columnas empezando por el 0. Es decir, el 1 indica que hay dos columnas.
android:layout_column: índice de la columna en la que queremos mostrar un elemento.
android:padding:el relleno
android:gravity: la manera de alinear el texto cuando es más pequeño que la vista.

Como veis es bastante parecido a las tablas HTML.

Curiosidad
Me ha parecido bastante curioso la forma de crear las lineas de separación entre las dos tablas:
<View
android:layout_height="2dip"
android:background="#FF909090" />
Es un elemento View, clase de la que heredan los TextView, etcétera, con una altura de 2dip (en otro post explicaré porqué es aconsejable usar este tipo de unidad), con un color de fondo determinado en RGB.

Hello Views II

2010-03-02T16:21:00.003+01:00

RelativeLayout
La clase RelativeLayout, al igual que LinearLayout, hereda de ViewGroup. Pero en este caso los elementos se muestran de manera relativa los unos con los otros.
Seguimos los pasos del tutorial:

Crear el proyecto con Eclipse indicando la Activity HelloRelativeLayout.
Crear o copiar el contenido del fichero main.xml
Cargar la vista en el método onCreate de nuestra Activity.
Ejecutar

En el fichero main.xml podemos identificar el inicio y el final de nuestro layout <RelativeLayout>...</RelativeLayout>. Pero en este caso lo más importante lo encontramos dentro de cada componente View, su posición relativa. En el ejemplo:

android:id="@+id/xxx": El + de @ que el id del elemento se crea automáticamente si no existe.
android:layout_below="@id/label": Debajo de. En el ejemplo podemos ver que la caja de texto está debajo de la etiqueta. Tenemos que poner el id del elemento del cuál nos posicionamos relativamente.
android:layout_alignParentRight="true": Si es cierto, el lado derecho del elemento coincide con el lado derecho del padre. Vemos que el botón de Ok, además de estar debajo de la caja de texto, está a la derecha, coincidiendo con el lado derecho del parent.
android:layout_marginLeft="10dip": Indica la cantidad de margen que queremos en el lado izquierdo de nuestro elemento.
android:layout_toLeftOf="@id/ok": A la izquierda de. En el ejemplo vemos como el botón de cancelar se sitúa a la izquierda del botón de Ok.
android:layout_alignTop="@id/ok": La parte superior alineado con. El lado superior del botón cancelar está a la misma altura que el lado superior del botón Ok.

Para otros atributos del RelativeLayout mirar RelativeLayout.LayoutParams.

Siempre es aconsejable manusear un poco el código que cogemos de ejemplo. ¿Lo habéis hecho? ¿Alguna duda?

Hello Views I

2010-03-02T11:19:00.006+01:00

Continuando con los recursos de Android Labs, lo siguiente que vamos hacer es un HelloWorld para cada tipo de vista. En esta primera entrega veremos el LinearLayout.

LinearLayout
Este layout es una vista en grupo, la cuál muestra los subelementos de manera lineal.Si vamos a la api de la clase LinearLayout vemos que hereda de la clase ViewGroup.
Vamos a seguir los pasos del tutorial:

Crear el proyecto con Eclipse indicando la Activity HelloLinearLayout.
Crear o copiar el contenido del fichero main.xml
Cargar la vista en el método onCreate de nuestra Activity.
Ejecutar

Como podemos ver en la pantalla tenemos dos layouts, uno horizontal mostrando 4 colores, y uno vertical mostrando 4 filas con texto:

Ahora vamos a comentar lo importante, el fichero main.xml. Como decíamos, podemos identificar los dos layouts:

<LinearLayout android:orientation="horizontal"...>...</LinearLayout>
<LinearLayout android:orientation="vertical"...>...</LinearLayout>

Los atributos que configuran nuestros LinearLayout son:

android:orientation :indica la orientación del layout.
android:layout_width: indica el modo de relleno a lo ancho. fill_parent hace que ocupe todo el espacio que nos deja el elemento "padre".
android:layout_height: indica el modo de relleno a lo largo/alto.
android:layout_weight: indica la importancia del elemento dentro de la vista. El 0 es el valor menos importante. (más información en Common Layout Objects)

Dentro de los LinearLayouts están los TextView que contienen el texto a enseñar, cosa que no es muy práctica pero que nos sirve para simplificar el ejemplo.

Dudas

Después de estar un rato jugando con el fichero main.xml y modificar los valores del atributo android:layout_weight de los TextView, he visto que efectivamente cambia el tamaño al variar los valores. Concretamente he puesto un 2 a los TextView rojo y amarillo, que han incrementado su tamaño pero no ocupan lo mismo, el amarillo ocupa más.

No sé cuál es el motivo, ¿pero es por el tamaño del texto? yellow es más largo que red.

Hello World / Hello Android

2010-02-28T02:12:00.002+01:00

Una vez tenemos el entorno preparado vamos hacer nuestro primer proyecto. Siguiendo como guía Android Labs, nos recomiendan hacer el típico HelloWorld.
Los pasos que nos indican son los siguientes:

Crear el AVD, que ya hicimos en el último paso del post anterior.
Crear el projecto en Eclipse.
Construir la Interfaz de Usuario dentro de la clase.
Ejecutar la aplicación.

Esta manera de crear la interfaz de usuario dentro del código se llama programática. Puede ser útil para interfaces sencillas, y también se puede utilizar para crear algún elemento de manera dinámica. Pero esta forma es difícil de mantener, y por ello Android ofrece la posibilidad de crear las IU a partir de layouts en ficheros XML. Por ejemplo:

<?xml version="1.0" encoding="utf-8"?> <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:text="@string/hello"/>

¿Dónde ubicamos estos ficheros XML? Primero vamos a ver la estructura de directorio:

src/: código de nuestras clases
gen/: código generado
assets/: desconozco!
res/drawable/: imágenes
res/layout/: layouts para nuestra IU
res/value/: textos

Para más detalles, recomiendo mirar Application Fundamentals. En los próximos post intentaré explicar de manera sencilla el contenido de esta página.

Ya hemos acabado con nuestro HelloWorld!! Si ejecutamos veremos que los resultados son iguales, tanto creando la IU programáticamente como con layouts.

Problemas

La guía de Android Labs es bastante sencilla de seguir, pero durante la realización me encontré con un problema. Después de estar jugando con los ficheros, me daba el siguiente error:

main.out.xml already defined

Después de googlear un rato no supe cuál era el motivo, pero lo solucioné eliminando el archivo main.out.xml a mano.

Preparando el entorno

2010-02-26T00:51:00.005+01:00

Para guiarme durante la instalación del entorno he seguido los pasos de la página oficial de Android Developers.

Lo primero que tenemos que hacer es descargarnos un IDE y el SDK de Android. Yo utilizaré Eclipse para Linux (Ubuntu 9.10).
Instalamos la última versión de Eclipse, en mi caso es la versión Galileo. Después descargamos la última versión del SDK de Android, ahora es la versión 2.1.

Ahora que ya tenemos las dos cosas básicas, vamos a preparar el entorno. Seguimos la página de guía y seguimos los pasos, que en resumen son:

Instalar el plugin ADT (Android Development Tools)
Indicamos el lugar donde tenemos descargado el SDK de Android
Poner en las variables de entorno el lugar donde tenemos el directorio tools del SDK. Para cada sistema operativo es diferente, en Linux se ha de modificar el fichero ./bashrc o ./bash_profile
Por último tenemos que crear el AVD (Android Virtual Device), es decir, el emulador. En Linux lo creamos desde la consola con el comando android create avd.

Problemas

Una vez instalado Eclipse para Linux, al menos con las versiones que trabajo, existe un bug que hace no funcionar correctamente los botones. Para solucionarlo me he creado el siguiente script para lanzar el Eclipse:

#!/bin/sh

export GDK_NATIVE_WINDOWS=true

/directorio_eclipse/eclipse

Inicio

2010-02-26T00:35:00.005+01:00

Después de mucho tiempo con la intención de ponerme en serio a aprender Android, Google me ha ayudado a lanzarme.

Hace una semana asistí por primera vez a una Technical Session de Android Labs, durante el Mobile World Congress 2010 de Barcelona. Al acabar la primera sesión, Introduction to Android Development (101), nos dieron a elegir a todos los asistentes entre un Google Nexus One o un Motorola Droid.

Yo escogí el Nexus One, y en un par de días tenía instalado ya el SDK!!!