gentoo linux, java, software libre y otras hierbas
Jul, 11 2010 - 2:08 pm

Iniciar servicio en android después del boot

Esta entrada, principalmente dedicada a mi mismo ya que se que se me va a olvidar cómo hacerlo, indica paso a paso como crear un servicio en Android que se ejecute al iniciar el sistema. Como sabemos, un servicio es un proceso que se ejecuta en background aun cuando ningún componente visual de nuestra aplicación se encuentre activo.

La idea es más o menos sencilla: una vez que un sistema Android ha iniciado envía una acción broadcast llamada android.intent.action.BOOT_COMPLETED. La idea es crear un BroadcastReceiver que escuche este tipo de acciones e inicie el servicio que deseemos. Así pues, el primer paso es crear una clase que extienda BroadcastReceiver:

public class Recibidor extends BroadcastReceiver{
	@Override
	public void onReceive(Context context, Intent intent) {
		Intent servicio = new Intent();
		servicio.setAction("foo.bar.Servicio");
		context.startService(servicio);
	}
}

Lo interesante aquí es que se ejecuta el método startService enviando como parámetro un Intent cuyo action es “foo.bar.Servicio”, el cual es el servicio que deseamos ejecutar. Dicho servicio es una clase que extiende de Service, y del cual debemos sobrescribir los métodos onCreate y onStart:

public class Servicio extends Service{

	private static final String TAG = "EjemploServicioBoot";

	private Timer timer;

	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}

	@Override
	public void onCreate(){
		super.onCreate();
		Log.d(TAG, "Servicio creado");
		timer = new Timer();
	}

	@Override
	public void onStart(final Intent intent, final int startId){
		super.onStart(intent, startId);
		timer.scheduleAtFixedRate(new TimerTask() {
			@Override
			public void run() {
				Log.i(TAG, "Se ejecuta la tarea");
			}
		}, 0, 15000);
	}
}

En este caso, el servicio realiza una tarea muy simple: imprime en el log del sistema un mensaje. Básicamente tenemos un objeto tipo Timer que ejecutará una tarea; en onCreate simplemente iniciamos el objeto Timer, mientras que en onStart usamos el método scheduleAtFixedRate indicando que ejecutaremos dicha tarea cada 15 segundos.

Por último, debemos registrar en el archivo AndroidManifest.xml el BroadcastReceiver y el servicio:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="foo.bar" android:versionCode="1" android:versionName="1.0">
    <application>
        <service android:name=".Servicio">
        	<intent-filter>
        		<action android:name="foo.bar.Servicio"/>
        	</intent-filter>
        </service>
        <receiver android:name=".Recibidor">
        	<intent-filter>
        		<action android:name="android.intent.action.BOOT_COMPLETED"/>
        	</intent-filter>
        </receiver>
    </application>
    <uses-sdk android:minSdkVersion="3" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
</manifest>

En el manifest podemos ver que añadimos un elemento service dentro de application, para registrar nuestro servicio. Y lo más interesante se ve en las líneas 12 y 17, que es donde indicamos el tipo de mensaje que nuestro recibidor estará esperando antes de ejecutar la tarea e indicamos que la aplicación requiere permisos para conocer cuando el boot del sistema a finalizado.

Descargar código fuente

Sin comentarios | deja el tuyo

Jun, 19 2010 - 8:50 pm

Sorteo 4 e-books de Android

Mark Murhpy es uno de los personajes más conocidos en el mundo de Android y el autor de 4 excelentes libros: The Busy Coder’s Guide to Android Development, The Busy Coders Guide to Advanced Android Development, Android Programming Tutorials y Android Beyond Java. El valor de los cuatro libros es de $40 USD, el cual es un precio bastante bajo para la calidad de los mismos.

Los ejemplos utilizados en los libros pueden ser descargados gratuitamente en el repositorio de Github. Además de esto, Mark es un usuario activo de StackOverflow.com… ¿y qué con eso? Bueno, personalmente me ha resuelto bastantes dudas allí (¿qué mejor que tener un experto dispuesto a solucionarte dudas puntuales?). También se le ve en twitter por si lo quieren seguir :D

En fin… Mark me ha enviado un cupón que permite subscribirse a su librería virtual por seis meses, y con la cual se puede acceder legalmente a todos sus contenidos. Los libros son actualizados regularmente cada mes o cada que sale una nueva versión del SDK. Además son distribuidos en formato PDF, EPUB o MOBI…

Así que pensé en sortear dicho cupón entre los lectores del blog que quisieran iniciarse en el mundo de Android (o que ya tengan experiencia pero quieran tener una referencia avanzada más directa). La verdad no sé que tanto pueda interesar a los lectores del blog el sorteo, pues no todos los que lo leen están interesados en la programación, pero no puedo dejar de compartir este valioso recurso con ustedes (tener en cuenta además que los libros están en inglés, por supuesto).

Así pues, si está interesado en adquirir estos títulos puede dejar un comentario indicando su interés, y si fuese posible la razón principal por la que desea aprender a desarrollar en esta plataforma (quisiera que el cupón se lo ganara alguien que realmente desea aprender del tema). El sorteo se realizará usando random.org (como habitualmente se hace) el día 2 de Julio (en honor al gran Andrés Escobar… bueno, en realidad es coincidencia pero sí le tenía bastante aprecio).

41 Comentarios | deja el tuyo

May, 09 2010 - 5:45 pm

Construir aplicaciones Android desde la línea de comandos

android consola

Emacs es algo adictivo sin duda… a tal punto que a veces prefiero programar todo desde la línea de comandos en vez de usar un IDE como Eclipse o Netbans. En esta entrada, que sin duda es de esas que me sirve solo a mi y a unos pocos más, se detalla el proceso de compilación e instalación de aplicaciones para Android sin usar más que el SDK y una línea de comandos. Esta guía es aplicable para cualquier sistema operativo, pero yo lo haré en mi equipo que corre Funtoo Linux.

0. Configuración del entorno de trabajo

Lo primero es tener el SDK instalado, lo cual está explicado aquí: Introducción a la programación con Android. Una vez hayamos instalado y configurado el SDK (incluyendo la adición del directorio tools al path del sistema) y tengamos un proyecto que compilar podemos iniciar el proceso de compilación. Es posible también crear el proyecto desde la línea de comandos así:

android create project -t 1 -p /tmp/ejemplo -k net.casidiablo.ejemplo -a Ejemplo

Donde -t 1 es el id de la plataforma para la que vamos a desarrollar la aplicación (el target). Se puede usar el comando android list targets para ver el listado de targets disponibles. -p indica la ruta de creación del proyecto y -a el nombre de la actividad inicial.

1. Compilación

Es posible usar Ant para compilar y empaquetar todo automáticamente… pero me gusta hacer cada cosa y saber qué está pasando por debajo. Así que haremos todo manualmente. El siguiente comando generará el archivo R.java (si no sabes de lo que hablo: Introducción a la programación con Android):

aapt p -m -J src -M AndroidManifest.xml -S res -I $ANDROID_DIR/android.jar
  • p = package
  • -m -j src indicar el directorio de los archivos fuente
  • -M indicar la ubicación del manifiesto
  • -S indicar la ubicación del directorio de recursos
  • -I $ANDROID_DIR/android.jar añade el paquete android.jar al classpath del proyecto. Importante: en mi caso $ANDROID_DIR apunta a /opt/android/platforms/android-4/ y en el path del sistema se encuentra incluido /opt/android/platforms/android-4/tools/ Es importante tener en cuenta que NO se usa la base del SDK como antiguamente se hacía, sino el correspondiente directorio bajo platforms.

Ahora sí vamos a generar los archivos .class (por supuesto, es necesario tener el JDK de Java instalado):

javac -encoding ascii -target 1.5 -d bin -bootclasspath $ANDROID_DIR/android.jar src/net/casidiablo/ejemplo/*.java

Esto básicamente genera archivos .class en el directorio bin. Si la aplicación usara librerías de terceros, se debería agregar el parámetro -classpath=libs/*.jar

Puesto que los archivos .class están generados para la JVM, es necesario convertirlos a archivos para la Dalvik VM:

dx –dex –output=bin/classes.dex bin # si existieran librerías externas se añade libs/*.jar

Ahora empaquetamos los recursos:

aapt p -f -M AndroidManifest.xml -S res/ -I $ANDROID_DIR/android.jar -F bin/ejemplo.ap_

Ahora empaquetamos usando los bytecodes de Dalvik que creamos (classes.dex) para generar el paquete final:

apkbuilder bin/ejemplo.apk -z bin/ejemplo.ap_ -f bin/classes.dex -rf src -rj libs

Finalmente podemos instalarlo tal como escribí en Manipulación de smartphones con Android desde la consola de Linux:

adb install bin/ejemplo.apk

Links interesantes: How to build Android application package (.apk) from the command line using the SDK tools + continuously integrated using CruiseControl y Developing Android without Eclipse or Ant

3 Comentarios | deja el tuyo

« Entradas anteriores