• Parte 1
• Parte 2

Luego hemos aprendido las bases para desarrollar aplicaciones con una interfaz de usuario:

• Parte 3

Ahora toca un nuevo componente muy importante: los servicios.

¿Qué es un servicio?

Un servicio es una aplicación que corre de forma automática, sin interacción con el usuario. Desarrollan tareas importantes para el resto de las aplicaciones o para el sistema.

Ejemplos de servicios son: servidores web, sistemas de comunicaciones, antivirus, etc…

Un detalle muy importante. En Android los servicios no son independientes, corren en el mismo proceso que la aplicación que los consume. Es un cambio de filosofía, pero una vez que se asuma, no implica mayor complejidad.

Empezando con el servicio

Primero, crearemos un nuevo proyecto Android desde Eclipse, con tan sólo una actividad (sin código adicional. Para ello usaremos el wizard de nuevo proyecto, pero no activaremos la casilla para crear un proyecto de prueba. Ésto nos dará un sólo archivo Java con el código de la actividad y su evento OnCreate.

package seroton.test.servicio;

import android.app.Activity;
import android.os.Bundle;

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

Vamos a modificar ése código para introducir el esqueleto de nuestro servicio. La primera gran diferencia es la clase de la que hereda, que en vez de ser Activiy ha de ser Service. Además, le meteremos los métodos requeridos por el interfaz (onBind) y otros métodos necesarios (OnDestroy, ServiceStart y ServiceStop). El esqueleto quedaría así:

package seroton.test.servicio;

import android.app.Service;
import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;

public class TestServicio extends Service
{
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate();

		// Iniciamos el serviciop
		this.iniciarServicio();
	}

	public void onDestroy()
	{
		super.onDestroy();

		// Detenemos el serviciop
		this.finalizarServicio();
	}

	public IBinder onBind(Intent intent)
	{
		// No usado de momento
		return null;
	}

	public void iniciarServicio()
	{
	}

	public void finalizarServicio()
	{
	}
}

Modificando el manifiesto

El archivo AndroidManifest.xml define toda la información que la máquina virtual Dalvik usará para ejecutar nuestra aplicación. Y ahora deberemos decirle que nuestra aplicación es en realidad un servicio. Para ello deberemos modificar el archivo que ha creado el wizard y escribir lo siguiente:

<?xml version="1.0" encoding="utf-8"?>
<manifest
	xmlns:android="http://schemas.android.com/apk/res/android"
	package="seroton.test.servicio"
	android:versionCode="1"
	android:versionName="1.0">

	<application android:label="@string/app_name">
		<service android:name="seroton.test.servicio.TestServicio"/>
	</application>

</manifest>

Haciendo que el servicio haga algo

Vale, ya tenemos nuestro servicio, pero ahora vamos a darle trabajo. Un servicio hace una tarea cada cierto tiempo, o cuando se dan ciertas condiciones. En éste ejemplo, vamos a hacer que nos muestre un mensaje cada cierto tiempo. Algo básico, pero que nos dá la idea de cómo funciona todo

Lo primero será crear un timer, un componente del sistema que realiza tareas cada cierto tiempo. Luego definiremos un método para ejecutar ésa tarea. También añadiremos el enlace para que pueda comunicarse con la actividad lanzadora (eso lo veremos luego). El código final de nuestro servicio sería:

package seroton.test.servicio;

import java.util.Timer;
import java.util.TimerTask;

import android.app.Activity;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
import android.os.Looper;
import android.widget.TextView;
import android.widget.Toast;
import android.util.Log;

public class TestServicio extends Service
{
	public static Activity ACTIVIDAD;
	private Timer timer = null;

	public static void establecerActividadPrincipal(Activity actividad)
	{
		TestServicio.ACTIVIDAD=actividad;
	}

	public void onCreate()
	{
		super.onCreate();

		// Iniciamos el servicio
		this.iniciarServicio();

		Log.i(getClass().getSimpleName(), "Servicio iniciado");
	}

	public void onDestroy()
	{
		super.onDestroy();

		// Detenemos el serviciop
		this.finalizarServicio();

		Log.i(getClass().getSimpleName(), "Servicio detenido");
	}

	public IBinder onBind(Intent intent)
	{
		// No usado de momento, sólo se usa si se va a  utilizar IPC
		// (Inter-Process Communication) para comunicarse entre procesos
		return null;
	}

	public void iniciarServicio()
	{
		try
		{
			Log.i(getClass().getSimpleName(), "Iniciando servicio...");

			// Creamos el timer
			this.timer=new Timer();

			// Configuramos lo que tiene que hacer
			this.timer.scheduleAtFixedRate
			(
				new TimerTask()
				{
					public void run()
					{
						ejecutarTarea();
					}
				},
				0,
				1000	// Cada segundo
			);

			Log.i(getClass().getSimpleName(), "Temporizador iniciado");
		}
		catch(Exception e)
		{
			Log.i(getClass().getSimpleName(), e.getMessage());
		}
	}

	public void finalizarServicio()
	{
		try
		{
			Log.i(getClass().getSimpleName(), "Finalizando servicio...");

			// Detenemos el timer
			this.timer.cancel();

			Log.i(getClass().getSimpleName(), "Temporizador detenido");

		}
		catch(Exception e)
		{
			Log.i(getClass().getSimpleName(), e.getMessage());
		}
	}

	private void ejecutarTarea()
	{
		Log.i(getClass().getSimpleName(), "Ejecutando tarea...");

		// Reflejamos la tarea en la actividad principal
		TestServicio.ACTIVIDAD.runOnUiThread
		(
			new Runnable()
			{
				public void run()
				{
					TextView ejecuciones=(TextView)TestServicio.ACTIVIDAD.findViewById(R.id.TextView01);
					ejecuciones.append(".");
				}
			}
		);
	}
}

Añadiendo un lanzador para el servicio

Bien, tenemos un servicio funcional, pero éste servicio no se ejecutará hasta que alguien lo pida. Haremos una pequeña actividad para lanzar éste servicio. No me dentendré en éste paso, porque básicamente vamos a usar lo mismo que ya dijimos en temas anteriores. Añadiremos controles para que el servicio pueda notificar sus acciones.

Creamos una nueva clase llamada TestServicioLanzador en el paquete donde está el servicio, con el código siguiente:

package seroton.test.servicio;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Looper;
import android.util.Log;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

public class TestServicioLanzador extends Activity
{
	ProgressBar barraProgreso=null;
	TextView ejecuciones=null;

	public void onCreate(Bundle savedInstanceState)
	{
	    // Iniciamos y establecemos el layout
	    super.onCreate(savedInstanceState);
	    setContentView(R.layout.main);

	    // Asociamos los controles
	    this.barraProgreso=(ProgressBar)findViewById(R.id.ProgressBar01);
	    this.ejecuciones=(TextView)findViewById(R.id.TextView01);

	    // Establecemos la actividad principal para el servicio
	    TestServicio.ACTIVIDAD=this;

	    // Iniciamos el servicio
	    try
	    {
			Log.i(getClass().getSimpleName(), "Iniciando servicio desde la actividad...");

			// Cogemos el intent el servicio
		    Intent servicio = new Intent(this, TestServicio.class);

		    // Lo ejecutamos
		    if(startService(servicio)==null)
		    {
		    	this.notificar("No se ha podido iniciar el servicio");
		    }
		    else
		    {
		    	this.notificar("Servicio iniciado correctamente");
		    }
	    }
	    catch(Exception e)
	    {
	    	this.notificar(e.getMessage());
	    }
	}

	public void onDestroy()
	{
		super.onDestroy();

		try
		{
			// Finalizamos el servicio
			Log.i(getClass().getSimpleName(), "Finalizando el servicio desde la actividad...");

			// Cogemos el intent el servicio
		    Intent servicio = new Intent(this, TestServicio.class);

		    // Lo ejecutamos
		    if(stopService(servicio))
		    {
		    	this.notificar("Servicio finalizado correctamente");
		    }
		    else
		    {
		    	this.notificar("No se ha podido finalizar el servicio");
		    }

			// Salimos
			this.finalize();
		}
	    catch (Throwable e)
	    {
	    	this.notificar(e.getMessage());
		}
	}

	private void notificar(String cadena)
	{
		// Notificamos con un toast
		Context contexto = getApplicationContext();

		CharSequence texto = cadena;
		int duracion = Toast.LENGTH_SHORT;

		Toast toast = Toast.makeText(contexto, texto, duracion);
		toast.show();
	}
}

Seguidamente definiremos el layout (en main.xml), que no tendrá nada especial:

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

	<TextView
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"
		android:text="Servicio iniciado. Puedes salir de ésta aplicación con las teclas Back o Home." />

</LinearLayout>

Y luego definiremos la actividad en el manifiesto, que quedaría de la forma siguiente:

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

<LinearLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="vertical"
	android:layout_width="fill_parent"
	android:layout_height="fill_parent">

	<TextView
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"
		android:text="Pulsa Back o Home para finalizar el servicio."
		android:padding="10px"/>

	<ProgressBar
		android:id="@+id/ProgressBar01"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:layout_gravity="center"></ProgressBar>

	<TextView
		android:id="@+id/TextView01"
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"
		android:text="Ejecuciones: "
		android:padding="10px"/>

</LinearLayout>

Para finalizar

Hemos creado un servicio muy básico, que podemos adaptar para hacer multitud de tareas sin la interacción del usuario.

Obviamente, la correcta ejecución del servicio también se podrá ver a través del log del sistema. Para verlo, usad el siguiente comando:

adb logcat

Éste comando se conectará con el log del emulador o del móvil que tengáis conectado, y lo mostrará por la ventana de la consola. Allí identificaréis claramente la salida.

¡A programar, gente!

• Es capaz de mostrar más de 4×4 iconos en el escritorio. El XPERIA X10 tiene una pantalla enorme, y una configuración de 4×5 iconos queda muuucho mejor que los espacios infinitos entre iconos del escritorio básico.
• Permite configurar múltiples escritorios, desde uno solo hasta un buen montón de ellos
• Permite asignar lanzadores rápidos al lado de la tecla del lanzador del menú, algo increíblemente cómodo cuando te acostumbras a ellos.
• Es precioso visualmente, aunque supongo que ésto ya va para gustos

Muchas más caracteristicas se esconden en el interior de ésta maravilla, pero tendréis que descargarla para verlas. Está en el market, pero si lo deseáis podéis usar éstos códigos QR para descargarlos:

• Versión para Android 1.6 (Donut)
  
• Versión para Android 2.0 (Eclair)
  

La página web oficial del proyecto es http://jbthemes.com/anderweb/, por si deseáis más información o queréis leer las últimas noticias de AnderWeb, su autor.

Os dejo con unas cuantas capturas más de ésta maravilla:

Por eso, se ha iniciado una petición para pedir a Sony Ericsson que actualize el XPERIA X10 a Android 2.2. No sé si servirá de algo, pero por lo menos hemos de intentarlo… Si deseas apoyar la iniciativa, firma aquí la petición. No tardarás ni un minuto.

Yo ya lo he hecho, y al momento de crear ésta entrada 465 personas también lo habían hecho. ¡Animate y firma!

• Se ha mejorado el compilador de la máquina virtual Dalvik, que hace que las aplicaciones corran entre 2 y 5 veces más rápido.
• Se añade soporte Exchange para el calendario. Muy útil para su sincronización con Outlook.
• Ahora se puede proteger la lista de contactos con una contraseña.
• Se ha añadido un nuevo motor Javascript, que hace que el navegador web se ejecute más rápido.
• El menú de aplicaciones del escritorio de ha mejorado añadiendo un par de iconos rápidos.
• Nuevo soporte para múltiples teclados. Ahora se pueden cambiar mientras se escribe, a través de un gesto de deslizamiento.
• Tethering nativo. O eso se afirma, aunque hasta que no lo vea no me lo creeré…
• Se han añadido mejoras en la grabación de video y la captura de fotos. Se ha añadido multitouch en la galería.
• Las nuevas APIs permitirán utilizar la nube de Google (Google Cloud) de forma nativa. Se añade la posibilidad de instalar aplicaciones en la SD.
• Se añade el envío de reportes de error a través del Market.

Ahora habrá que morderse las uñas hasta que o se consiga rootear el X10 y pueda poner una rom con éste nuevo Android 2.2, o que Sony quiera actualizar el cacharro, lo que creo que de momento no va a pasar…

Fuente: and.roid.es

De todas formas es un primer paso, ya que con éstas técnicas la gente de XDA Developers podrá, con el tiempo, encontrar una técnica tan sencilla como la utilizada para ganar acceso root en los terminales de HTC.

Genial noticia, sin duda
Fuente: androidcommunity.com

Éste nuevo teléfono es un auténtico pepino. Con todo un Snapdragon de 1 ghz, en su interior y una enorme pantalla de 4 pulgadas, el Xperia se ve grande y poderoso, aunque, como contrapunto, las modificaciones de Sony al Android que le mueve no son muy satisfactorias. El móvil mejorará mucho cuando la scene empiece a sacar roms para él y pueda ponerle un Android menos modificado.

Con tan sólo éste pequeño tiempo de prueba, ya os puedo decir algunas cositas del teléfono:

Lo bueno:

• Se nota el micro extra, va muy fluido
• Se nota igualmente la RAM extra
• Aunque es tan grande el móvil es cómodo de llevar
• La agenda de Sony es bastane mejor que la agenda básica de Android

Lo malo:

• Sistema operativo Android demasiado modificado
• Basado en 1.6 en vez de en 2.1, a ver si actualizan pronto…
• Hay un bug en el sistema de sonido que hace qu muy puntualmente algunas llamadas suenen raro.

Cuando sepa más, más os diré. ¡Hasta pronto!

El reproductor Flash poco a poco va acercándose a todos los dispositivos móviles modernos, como las Blackberrys de RIM, los diferentes Androids, etc. Incluso a los IPhones de Apple, con lu duro que es pasar el bloqueo de Steve Jobs . Y ya hay comparativas que muestran la misma aplicación flash corriendo en dos dispositivos con dos sistemas operativos diferentes:

Pinche aquí para ver el vídeo

Interesante, ¿no? Pues si queires hacer ésta prueba ya puedes hacerlo. Para registrarse para probar la beta basta con seguir éste enlace. Yo ya lo he hecho, ya os contaré cuando me avisen

El ejemplo que ellos dan es significativo: la aplicación de E-Mail. Si eres como casi todos, y lees todas tus cuentas de correo desde GMail, ésta aplicación no es necesaria y desinstalarla nos dará un mega de memoria que nos viene de perlas. Y todo ésto podremos repetirlo con cuantas aplicaciones deseemos.

Necesitaremos acceso root y una aplicación La aplicación es Root Explorer, que se puede comprar por 1,30 libras en el Market. Recordad: iempre podéis comprarlo, hacer éste tutorial y pedir el reembolso de la compra, si estáis reacios a pagar

Los pasos para quitar la aplicación de e-Mail son los siguientes:

1. Vamos al directorio /system/app y pulsamos el botón ‘Mount R/W‘ para que Root Explorer pueda efectuar cambios en el sistema.
2. Copiamos el archivo /system/app/email.apk a la tarjeta SD, pro si queremos volver a instalar la aplicación en algún momento.
3. Borramos el archivo /system/app/email.apk.
4. Borramos el archivo /data/dalvik-cache/system@app@email.apk@clases.dex, que es lo que consume memoria en si.
5. Repetir los pasos 2-4 con tantas aplicaciones como deseemos, buscando en /data/dalvik-cache el archivo de caché correspondiente.
6. Al finalizar, volvemos al directorio /system/app y pulsamos el botón ‘Mount R/O‘ para restaurar el estado previo.

Yo lo he hecho sin problemas, no deberíais tener ningún problema. ¡A por esa memoria RAM, gente!

• Parte 1: Preparando el entorno
• Parte 2: Conceptos iniciales

Ha pasado mucho tiempo, pero volvemos a la carga

Tras preparar el entorno y ver todos los conceptos de una aplicación Android, vamos a crear y gestionar interfaces de usuario y sus eventos. Éstas interfaces serán nuestro medio de comunicación con el usuario. Comencemos.

Creando una interfaz

El plugin ADT que hemos instalado en nuestro Eclipse nos porporciona un editor gráfico para hacer las interfaces. A mi no me gusta demasiado, aún le queda mucho trabajo por delante para ser usable, por lo que generaremos nuestras interfaces directamente en XML.

Los directorios importantes de nuestra aplicación eran:

• src: Aquí irá el código fuente que gestiona cada una de las actividades (y demás)
• res/drawable: Aquí irán recursos gráficos, como imágenes, etc.
• res/layout: Aquí se definirán todas las interfaces de la aplicación
• res/values: Aquí se especifican las cadenas de la aplicación

La interfaz por defecto está en res/layout/main.xml. Editaremos éste archivo y colocaremos un par de controles para probar la gestión de eventos. Éste es el XML de la interfaz que usaremos en éste ejemplo. Para más información sobre los diferentes widgets de la interfaz, leer ésta página.

<?xml version=”1.0″ encoding=”utf-8″?>

<LinearLayout
xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
android:padding=”10px”>

<TextView
android:text=”@string/introduccion”
android:id=”@+id/TextViewIntroduccion”
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”></TextView>

<EditText
android:text=”@string/prueba”
android:id=”@+id/editTextPrueba”
android:layout_height=”wrap_content”
android:layout_width=”fill_parent”
android:layout_marginTop=”5px”></EditText>

<Button
android:text=”@string/boton”
android:id=”@+id/buttonPrueba”
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:clickable=”true”
android:layout_gravity=”right”
android:layout_marginTop=”5px”></Button>

</LinearLayout>

Meteremos las cadenas necesarias en res/values/strings.xml:

<?xml version=”1.0″ encoding=”utf-8″?>
<resources>
<string name=”app_name”>Tutorial de Diario de un Androide</string>
<string name=”introduccion”>Introduce lo que desees y pulsa el botón para que se desate la magia </string>
<string name=”boton”>¡Dámelo!</string>
<string name=”prueba”>Quiero, quiero…</string>
</resources>

Y con éste paso terminado, ya tendremos un control del que coger información (la caja de texto) y un control del que capturar un evento (el botón), lo que nos dirá cómo gestionar los eventos de nuestra aplicación Android, ya que todos los controls se comportan básicamente de la misma forma.

La interfaz quedaría de ésta forma:

Vayamos ahora con la gestión a nivel de código.

Gestionando los eventos de la interfaz

Los eventos se gestionan a través de Listeners. Nuestra clase deberá implementar los listeners necesarios (uno por cada uno de los eventos posibles), e implementar los métodos que capturarán los eventos. Los pasos para, por ejemplo, capturar un botón, serían los siguientes:

1. Hacer que la clase implemente los listeners necesarios y añadir los métodos que se requieran (Eclipse puede hacerlo automáticamente).
2. Capturar los controles de la interfaz en el método onCreate, y asociar sus listeners a la clase.
3. Implementar los gestores de eventos para cada control en cada uno de los métodos de los listeners.

El código completo del ejemplo, con todo lo explicado hasta ahora, es el siguiente. Está bastante comentado, para explicar cada una de las partes. éste código estaría en el archivo de la clase principal, en éste caso src/tutorialWeb.java.

package serone.tutorialWeb;

/**
* Tutorial para la web androide.hijodeblog.com
* @author Dr. SeROne (doctor@serone.org)
*/

// Inclusiones necesarias
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

/**
* Clase de la actividad principal del tutorial
* @author Dr. SeROne (doctor@serone.org)
*/
public class tutorialWeb extends Activity implements OnClickListener
{
// Propiedades de la clase
Button botonPrueba=null;
EditText editTextPrueba=null;

/**
* Ciclo de vida de la actividad
*/
@Override public void onCreate(Bundle savedInstanceState)
{
// Pasamos la información dela instancia a la clase padre
super.onCreate(savedInstanceState);

// Especificamos el contenido de la interfaz de ésta actividad
// (que será nuestro main.xml, en éste caso)
setContentView(R.layout.main);

// Capturaremos los controles de la interfaz, asociándolos a los
// gestores de eventos (ésta clase, en éste caso) si es necesario.
// Haremos ésto con cada uno de los controles que requieran que sus
// eventos se procesen en ésta actividad.

// Botón
this.botonPrueba=(Button)findViewById(R.id.buttonPrueba);
if(this.botonPrueba!=null) this.botonPrueba.setOnClickListener(this);

// Área de texto
this.editTextPrueba=(EditText)findViewById(R.id.editTextPrueba);
}

/**
* Gestor de los eventos Click
*/
@Override public void onClick(View vista)
{
// Filtramos los controles
if(vista.getId()==R.id.buttonPrueba)
{
// Informaremos al usuario con una notificación de tipo Toast, un
// popup que se muestra brevemente al usuario
Toast notificacionToast=Toast.makeText(
getApplicationContext(),
“¿Quieres un “+this.editTextPrueba.getText()+”? ¿Sólo eso? ¡Te lo concedo!”,
Toast.LENGTH_SHORT);
notificacionToast.show();
}
}
}

Disculpad la indentación lamentable, cuando pueda corregiré éstos aspectos con el plugin correspondiente, pero hoy no tengo tiempo…

El resultado de la ejecución sería:

Conclusión

Con éste sencillo evento, hemos aprendido a extraer información y gestionar casi todos los controles disponibles en una aplicación Android, pues todos se comportan de la misma forma. En las siguientes lecciones veremos más controles vitales (como menús, solapas, etc) y la forma de tener más de una actividad por aplicación, para poder crear aplicaciones mucho más ricas.

¡Hasta la próxima lección, androides!

Su nombre es AutoMount (bastante explicativo, ¿eh?), y lo podéis encontrar de forma totalmente gratuita en el Android Market.

¡Una instalación obligada!