Índice. 1. Motivación Pag Desarrollo parte 1 Pag Desarrollo parte 2 Pag Bibliografía Pag 19

(1)

(2)

(3)

Índice

1. Motivación Pag 3

2. Introducción a Android Pag 3

3. Instalación Pag 5

4. Desarrollo parte 1 Pag 6

5. Desarrollo parte 2 Pag 9

6. Conclusiones Pag 18

7. Glosario Pag 18

8. Bibliografía Pag 19

(4)

(5)

Motivación

1. En la carrera no se ve algún tipo de tema relacionado a desarrollo de aplicaciones para móviles.

2. El desarrollo de aplicaciones para dispositivos móviles a crecido exponencialmente en los últimos años.

3. Android me parece un S.O muy versátil y novedoso.

4. Quisiera dedicarme de manera profesional en algún momento a desarrollar aplicaciones en esta plataforma.

Introducción al Sistema operativo Android

Android es un sistema operativo basado en Linux, diseñado principalmente para móviles con pantalla táctil como teléfonos inteligentes o tabletas inicialmente desarrollado por Android Inc., que Google respaldó económicamente y más tarde compró en 2005.

Android fue desvelado en 2007 junto a la fundación del Open Handset Alliance: un consorcio de compañías de hardware, software y telecomunicaciones con el objetivo de avanzar en los estándares abiertos de los dispositivos móviles. El primer móvil con el sistema operativo Android se vendió en octubre de 2008.

Actualmente existe una gran comunidad de desarrolladores escribiendo aplicaciones para extender la funcionalidad de los dispositivos Android. A la fecha, se han sobrepasado las 700,000 aplicaciones (de las cuales, dos tercios son gratuitas) disponibles para la tienda de aplicaciones oficial de Android:

Google Play.

La estructura del sistema operativo Android se compone de aplicaciones que se ejecutan en un framework Java en una máquina virtual llamada Dalvik con compilación en tiempo de ejecución.

Arquitectura

1.Aplicaciones: Las aplicaciones base incluyen un cliente de correo electrónico, programas de envio de mensajes de texto, calendario, mapas, navegador, contactos y otros. Todas las aplicaciones están escritas en lenguaje de programación Java.

2.Marco de trabajo de aplicaciones: los desarrolladores tienen acceso completo a los mismos APIs del framework usados por las aplicaciones base. La arquitectura está diseñada para simplificar la

reutilización de componentes; cualquier aplicación puede publicar sus capacidades y cualquier otra aplicación puede luego hacer uso de esas capacidades (sujeto a las reglas de seguridad del framework).

3.Bibliotecas: Android incluye un conjunto de bibliotecas de C/C++ usadas por varios componentes del sistema. Estas características se exponen a los desarrolladores a través del marco de trabajo de

aplicaciones de Android; algunas son: System C library (implementación biblioteca C estándar), bibliotecas de medios, bibliotecas de gráficos, 3D y SQLite, entre otras.

(6)

4.Runtime de Android: Android incluye un set de bibliotecas base que proporcionan la mayor parte de las funciones disponibles en las bibliotecas base del lenguaje Java. Cada aplicación Android corre su propio proceso, con su propia instancia de la máquina virtual Dalvik. Dalvik ha sido escrito de forma que un dispositivo puede correr múltiples máquinas virtuales de forma eficiente. Dalvik ejecuta archivos en el formato Dalvik Executable (.dex), el cual está optimizado para memoria mínima. La Máquina Virtual está basada en registros y corre clases compiladas por el compilador de Java que han sido transformadas al formato .dex por la herramienta incluida "dx”.

5.Núcleo Linux: Android depende de Linux para los servicios base del sistema como seguridad, gestión de memoria, gestión de procesos, pila de red y modelo de controladores. El núcleo también actúa como una capa de abstracción entre el hardware y el resto de la pila de software.

Android, al contrario de otros sistemas operativos para dispositivos móviles como IOS o Windows Phone, se desarrolla de forma abierta y se puede acceder tanto al código fuente cómo a la lista de incidencias donde se pueden ver problemas aún no resueltos y reportar problemas nuevos.

El que se tenga acceso al código fuente no significa que se pueda tener siempre la última versión de Android en un determinado móvil, ya que el código para soportar el hardware (controladores) de cada fabricante normalmente no es público, así que faltaría un trozo básico del firmware para poder hacerlo funcionar en dicha terminal, y porque las nuevas versiones de Android suelen requerir más recursos, por lo que los modelos más antiguos quedan descartados por razones de memoria (RAM), velocidad de procesador, etc

El logotipo de Android es el robot "Andy".

El sistema operativo está compuesto por 12 millones de líneas de código, incluyendo 3 millones de líneas de XML, 2.8 millones de líneas de lenguaje C, 2.1 millones de líneas de Java y 1.75 millones de líneas de C++.

Instalación

El primer paso que debemos seguir es instalar el compilador de Java y la máquina virtual. Estas herramientas las podemos descargar de

http://www.oracle.com/technetwork/es/java/javase/downloads/index.html y de http://www.eclipse.org/.

(7)

El segundo paso es la descarga del SDK de Android desde http://developer.android.com/sdk/index.html Luego descomprimimos el SDK en cualquier carpeta en nuestra computadora.

Cuando Eclipse se esté ejecutando se va a la ruta Help->Install New Software.

Hacer clic sobre la ventana de Available Software.

En el campo nombre se ingresa “Android Developer Tools” (sin las comillas).

En la URL ponemos https://dl-ssl.google.com/android/eclipse/

Después dar clic sobre “Next”, a continuación clic en “Finish” y después reiniciar Eclipse.

Con esto ya queda listo Eclipse para poder programar Android.

Cabe señalar que se pueden presentar problemas de incompatibilidad entre las versiones recientes del SDK de Android y las versiones antiguas de eclipse para ello se puede optar por instalar una versión más antigua del SDK y luego ya instalado: actualizar .

Desarrollo primera parte

Para la primera parte del proyecto, se investigó acerca de el entorno de desarrollo Android y los fundamentos para programar en este SO. Además, se hizo una pequeña aplicación que utiliza base de datos y demás instrumentos básicos del propio lenguaje.

El programa que se hizo en la primera parte del proyecto fue un programa que hace un registro de asistentes en la entrada de cierto centro cultural, en la entrada estaría una persona que elegiría entre rango de edades y sexo.

Se tiene un boton de guardado y 2 group radio button además de un Textview donde se mostrará el contador de visitantes.

@Override

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

setContentView(R.layout.activity_control_visitas);

TextView contador = (TextView)findViewById(R.id.textView1);

contador.setText(Integer.toString(cont)+" Visitantes recibidos");

}

(8)

Dentro del método sobre escrito “onCreate” (onCreate indica que hacer cuando se abre el programa y siempre se debe sobreescribir ) se le pasa como referencia al objeto contador del tipo Textview el text view creado en el xml control_visitas para poder modificarlo desde el código java.

Después se muestra por medio del método setText en pantalla el número de visitantes recibidos en el textview.

El método “basedatosr”, es el método que se llamará cuando se haga clic en el boton guardar se puede hacer de dos maneras se puede sobreescribrir el método “onclick” del boton guardar o se puede modificar el XML, éste último parece ser el método más adecuado , rápido y fácil.

<Button

android:id="@+id/button1"

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_below="@+id/radioGroup2"

android:onClick="basedatosr" <--- Nombre del método a ser llamado cuando se android:text="@string/guardar" da clic en el boton.

android:textSize="@dimen/cuarenta"

android:textStyle="bold" />

El método “basedatosr” es el siguiente :

public void basedatosr(View v) {

final RadioButton ninhos,jovenes,adultos,adultosm,hombre,mujer;

final RadioGroup

genero=(RadioGroup)findViewById(R.id.radioGroup1),edad=(RadioGroup)findViewById(R.id.radioGroup2);

Date horaent=new Date();

String auxiliar=new String();

ninhos=(RadioButton)findViewById(R.id.radio1);

jovenes=(RadioButton)findViewById(R.id.radioButton1);

adultos=(RadioButton)findViewById(R.id.radio2);

adultosm=(RadioButton)findViewById(R.id.radio0);

hombre=(RadioButton)findViewById(R.id.radio3);

mujer=(RadioButton)findViewById(R.id.radio4);

final basededatos db= new basededatos(this, "VisitantesBD", null, 1);

auxiliar=contador.getText().toString();

ContentValues valores=new ContentValues();

MediaPlayer mp=MediaPlayer.create(this,R.raw.bip),mp2=MediaPlayer.create(this,R.raw.error);

SQLiteDatabase based = db.getWritableDatabase();

if(hombre.isChecked())

{ valores.put("genero", "Hombre");

if(ninhos.isChecked()) {valores.put("edad", "ninio");

valores.put("hora",horaent.toString());

based.insert("Visitantes", null,valores);

mp.start();cont=cont+1;}

if(jovenes.isChecked()) {valores.put("edad", "joven");

(9)

mp.start();cont=cont+1;

}

if(adultos.isChecked()) {valores.put("edad", "adulto");

if(adultosm.isChecked())

{valores.put("edad", "adulto_mayor");

}

if(mujer.isChecked())

{ valores.put("genero", "Mujer");

if(ninhos.isChecked()) {valores.put("edad", "ninio");

if(jovenes.isChecked()) {valores.put("edad", "joven");

if(adultos.isChecked()) {valores.put("edad", "adulto");

if(adultosm.isChecked())

{valores.put("edad", "adulto_mayor");

mp.start();

cont=cont+1;}

}

if((!((mujer.isChecked())||(hombre.isChecked()))||!((ninhos.isChecked())||(jovenes.isChecked())||(adultos.isChecked())||(adul tosm.isChecked()))))

{mp2.start();}

genero.clearCheck();

edad.clearCheck();

based.close();

}

En este método se crean varios objetos

1. RadioButtons y Radio Group para referenciar los radiobuttons del xml(activity).

2. Objeto “Date” (se guarda la fecha en la base de datos).

3. Objeto “Basedatos”, será la base de datos donde se guarda la información.

4. Objeto “content values” en este se guardan temporalmente los datos a ser guardados antes de llegar a la base de datos.

5. Objeto MediaPlayer, éste objeto servirá para reproducir un sonido, de ingreso correcto en los datos o ingreso erroneo.

(10)

Después, se verifica caso por caso cuales “radio group” están marcados, por ejemplo: si están marcadas las opciones “Mujeres” y “niño” se guarda en la base de datos “mujer” “ninio” “fecha”, se aumenta el contador de visitantes,se activa el sonido de inserción correcta y se limpia la selección.

En el caso en que se hace una selección no válida y se presiona el boton de guardar, se manda sonido de error, se limpia la selección y no se inserta nada en la base de datos.

Ahora el código de la base de datos:

public class basededatos extends SQLiteOpenHelper {

public basededatos(Context context, String name, CursorFactory factory, int version) {

super(context, name, factory, version);

}

String createdb="CREATE TABLE Visitantes (genero TEXT,edad TEXT,hora TEXT)";

@Override

public void onCreate(SQLiteDatabase db) { //Se ejecuta la sentencia SQL de creación de la tabla db.execSQL(createdb);

}

@Override

public void onUpgrade(SQLiteDatabase db, int AVersion, int Nversion){}

}

En este código simplemente se sobreescribe el método sqlite* para personalizar la base de datos a nuestro antojo, se crea un string con el código sql que queremos que se ejecute y luego indicamos que cuando se cree la base de datos se ejecute lo que dice el string, también se puede modificar

“onupgrade” aunque ese método es opcional de sobreescribir sólo sirve para indicar que hacer cada vez que se mande un upgrade a la base de datos y que versión se quiere modificar.

Desarrollo parte 2

Esta parte del proyecto se destinó a investigar acerca de temas un pocos más avanzados en Android, el primero fue implementar gestos en la pantalla, el segundo fue el acelerómetro, para ambos temas se hizo un pequeño programa.

En la primera parte se trabajó con gestos en la pantalla (gestures), en ésta se hizo un pequeño y sencillo reproductor de música el cual se explica a continuación:

Lo primero a hacer es crear los gestos a utilizar, esto se hace entrando al emulador de Android ejecutando la aplicación “gestures builder” en este caso se crearon 2:

(11)

Después salimos del emulador y vamos a la perpectiva DDMS de Eclipse, ahí en el navegador buscamos la carpeta data/data/gesturebuilder/ y ahí elegimos la opción de guardar el archivo gestures en la computadora, una vez hecho esto se guarda en la carpeta RAW del proyecto.

Por último viene la parte del código:

@Override

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

setContentView(R.layout.activity_android_gesture);

(12)

mLibrary = GestureLibraries.fromRawResource(this, R.raw.gestures);

if (!mLibrary.load()) { finish();

}

GestureOverlayView gestures = (GestureOverlayView) findViewById(R.id.gestures);

gestures.addOnGesturePerformedListener(this);

}

Cómo siempre se sobrecarga el método “on create”, en el se crea un objeto Gesturelibraries referenciado por nuestro archivo de gestos ,es decir acá están todos los gestos creados.Se creó un objeto que hace referencia a la plantilla donde se dibujan los gestos en el teléfono y se le pasa un listener(este sirve para “atender” cada dibujo que se haga en la pantalla).

public void onGesturePerformed(GestureOverlayView overlay, Gesture gesture) {

ArrayList<Prediction> predictions = mLibrary.recognize(gesture);

MediaPlayer mp=MediaPlayer.create(this,R.raw.yellow);

if (predictions.size() > 0 && predictions.get(0).score > 1.0) { String result = predictions.get(0).name;

if ("play".equalsIgnoreCase(result)) { contador.setText("Ha elegido reproducir");

mp.start();

} else if ("stop".equalsIgnoreCase(result)) { contador.setText("Ha elegido detener");

mp.stop();

}

else{contador.setText("No se que opcion me pides");}

}

Después se crea un arreglo de “predictores de gestos”, así cómo el reproductor de música y se le pasa como referencia la canción que ya está en la carpeta raw.

Si el número de gestos predecidos es mayor a cero, se reconoció al menos uno de los gestos dibujados entonces, se recoje el nombre del gesto que se reconoció y si es igual a “play” se reproduce la canción, en el caso en que se reconoció “stop” se detiene la canción; si el usuario dibujó algo distinto a nuestros gestos ya guardados se manda un mensaje de que “no se sabe” que quiere hacer el usuario.

(13)

Programa 2 :acelerómetro

En la parte final del proyecto se decidió trabajar con el acelerómetro* el objetivo era hacer un programa capaz de reconocer movimientos de la mano y en base a eso realizar una acción.

A continuación se muestra como se logró esto:

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

setContentView(R.layout.activity_practica_acelerometro2);

x = (TextView)findViewById(R.id.xID);

y = (TextView)findViewById(R.id.yID);

z = (TextView)findViewById(R.id.zID);

this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

}

Cómo siempre se sobrescribe el método “oncreate” para cualquier “activity”, sólamente se crean textview, en el se mostrarán los valores del acelerómetro.

Este programa es diferente a los demás debido a que en éste sí se sobreescribieron los métodos “onpause()” y

“onResume()”.

protected void onResume() {

super.onResume();

SensorManager sm = (SensorManager) getSystemService(SENSOR_SERVICE);

List<Sensor> sensors = sm.getSensorList(Sensor.TYPE_ACCELEROMETER);

if (sensors.size() > 0) //dispositivo android tiene acelerometro {

sm.registerListener(this, sensors.get(0), SensorManager.SENSOR_DELAY_GAME);

} }

En “on resume” se activa el acelerómetro es decir, cada vez que se abra la aplicación o regrese de segundo plano, además, se crea un listener para el con parametros cómo el tipo de sensor ( en este caso acelerometro) y el retardo para ser

inicializado.

protected void onPause() {

SensorManager mSensorManager=(SensorManager) getSystemService(SENSOR_SERVICE);

mSensorManager.unregisterListener(this, mAccelerometer);

super.onPause();

}

protected void onStop() {

SensorManager mSensorManager=(SensorManager) getSystemService(SENSOR_SERVICE);

mSensorManager.unregisterListener(this, mAccelerometer);

super.onStop();

}

En los métodos “on pause” y “onstop” se tiene el mismo código es decir cuando se pause o se detenga la aplicación se deja de “escuchar” al acelerómetro.

Luego viene el código del listener del acelerómetro, acá se hace practicamente todo:

(14)

public void onSensorChanged(SensorEvent event) { // TODO Auto-generated method stub

this.listax.insertar(event.values[0]);

this.listaxp.insertar(this.listax.promedio());

this.listay.insertar(event.values[1]);

this.listayp.insertar(this.listay.promedio());

this.listaz.insertar(event.values[2]);

this.listazp.insertar(this.listaz.promedio());

comosemueve=movimiento(this.listayp.derivada(),this.listaxp.derivada(),this.listazp.derivada());

if(this.mover.equals(comosemueve))

{lanzar.setData(Uri.parse("http://www.google.com"));

startActivity(lanzar);}

else if (this.movera.equals(comosemueve))

{lanzar.setData(Uri.parse("http://www.youtube.com"));

startActivity(lanzar);

} }

Se tienen varias listas que fueron implementadas con colas circulares, más adelante se muestra su código,en ellas se insertan los valores del acelerómetro por medio de la función insertar.

Los valores del acelerómetro se pueden ver así en pantalla:

Estos están en event.values[0](x),event.values[1](y),event.values[2](z).

Un problema que se tuvo es que aún dejando en una mesa sin mover el teléfono o dispositivo Android, los valores del acelerómetro oscilaban, esto provocaba “ruido en la señal” que nos podia hacer detectar falsos movimientos.

(15)

Gráfica con ruido.

Por este motivo se decidió hacer un filtro pasa bajos*, en el caso de este programa utilizamos como filtro el promedio en el movimiento. Y ese movimiento ya promediado se agregaba a una lista ya promediada que generaba menos ruido en la señal.

Señal del acelerómetro pasada por el filtro

4.60000 4.80000 5.00000 5.20000 5.40000 5.60000 5.80000

-6.00000 -4.00000 -2.00000 0.00000 2.00000 4.00000 6.00000 8.00000 10.00000 12.00000

Columna C

0 0.2 0.4 0.6 0.8 1 1.2

-4.0000 -2.0000 0.0000 2.0000 4.0000 6.0000 8.0000

Columna C

(16)

Después de esto se sacó la derivada a la gráfica ya promediada , que sirvió como filtro pasa altos , cómo se sabe la derivada del movimiento respecto al tiempo nos da como resultado la velocidad es decir, la derivada nos indicaba que tan veloz se movía el teléfono en un momento dado.

Velocidad de cambio ( velocidad max:150 en z)

Como se puede observar, en los picos es donde se genera el movimiento es decir, donde hay mayor velocidad,otra observación es que la máxima velocidad para los ejes es distinta debido a la forma con que se mueve la mano o con qué mano se agarra.

Entonces por eso al final del código, se llama a la función llamada movimiento que regresa un string este string nos servirá para ver los tipos de movimiento, a la función movimiento se le pasa las 3 derivadas en x y y z , en base a eso se lleva a cabo una acción.En este caso, se crea un intent* para abrir una página web en el tipo “arriba” se abre google.com en el caso “abajo” se abre youtube.com pero no sólo se puede hacer esto, no hay límite para lo que pueda realizar el teléfono al detectar los

movimientos.

public String movimiento(double ye,double equis,double ze) { String prueba=" ";

x.setText(Double.toString(ze));

if(ze>200)

{prueba="arriba";}

else if(equis>130) {prueba="abajo";}

return prueba;

}

Ahora se muestra el código que implementa las colas circulares.

0 0.2 0.4 0.6 0.8 1 1.2

-200 -150 -100 -50 0 50 100 150 200

Columna B

(17)

Constructor

public Colacircular(int tam) { int i=0;

frente=0;

elementos=0;

fin=tam-1;

arreglo=new float[tam];

for (i=0;i<tam;i++) {arreglo[i]=0;}

}

“Elementos” nos marca la cantidad de números insertados en el arreglo.

“Frente” marca el frente de la cola.

“Fin” marca el final de la cola.

Arreglo:aquí se insertan los datos a ser tratados.

public boolean estallena()

{if(this.elementos==fin+1) return true;

else

return false;

}

Nos indica si la cola está llena.

public void insertar(float elem) {

if(this.estallena()==false)

{this.arreglo[this.elementos]=elem;

this.elementos=this.elementos+1;

} else

{this.elementos=1;

this.arreglo[0]=elem;

} }

Inserta elementos en la cola, si está llena comienza a llenar de nuevo desde el principio (cola circular)

public int elementost()

{return this.elementos;}

Regresa la cantidad de elementos presentes en la cola.

public void vaciar() {this.elementos=0;

}

Deja vacía la cola ( sólo fue necesaria al principio después no se utilizó ya que una cola circular nunca se vacía)

public boolean estavacia()

{if(this.elementos==0){return true;}

else return false;

} Mismo caso que vaciar

public float promedio() {int i=0,j=0;

(18)

float suma=0;

float promedio=0;

for(i=this.elementos;i<this.fin+1;i++) {suma=this.arreglo[i]+suma;}

for(j=0;j<this.elementos;j++) {suma=this.arreglo[j]+suma;}

promedio=suma/(this.fin+1);

promedio=suma/this.elementos;

return promedio;

}

La función “promedio” actua como filtro pasa bajos o “suavizador”(smoother) del que se habló antes.

double derivada()

{ double deriv=0;

if(this.elementos==1)

{deriv=(this.arreglo[this.elementos-1]-this.arreglo[this.fin])/0.02;}

else{deriv=(this.arreglo[this.elementos-1]-this.arreglo[this.elementos-2])/0.02;}

return deriv;

}

La función “derivada” da la razón de cambio respecto al tiempo.

Cómo parte adicional se muestra el código que se utilizó para guardar datos en un archivo del

dispositivo Android utilizado, el cual sirvió para hacer las gráficas y cálculos en Excel para calibrar el dispositivo.

public void escribir(String nombreArchivo,Colacircular datos,Colacircular datos2) {int i =0;

String estado = Environment.getExternalStorageState();

if (estado.equals(Environment.MEDIA_MOUNTED)) {//Escritura

try{File ruta_sd = Environment.getExternalStorageDirectory();

File f = new File(ruta_sd.getAbsolutePath(), nombreArchivo);

OutputStreamWriter fout = new OutputStreamWriter(

new FileOutputStream(f));

for(i=0;i<tam;i++)

{fout.append(datos.arreglo[i]+","+datos2.arreglo[i]+"\n");

}

fout.close();

}catch(Exception ex){};

} }

Lo que hace este código básicamente, es crear streamings de escritura y el archivo con la ruta absoluta de la tarjeta SD y se va escribiendo sobre el archivo al final se cierra y listo.

(19)

Aparte de este código se tuvieron que agregar permisos de escritura en el XML en el manifest del proyecto.

Conclusiones

1. En la primera parte se investigó lo más básico empezando con tutoriales unos en inglés ( que son la gran mayoría ) y otros en español; todavía se debe seguir trabajando para tener mas documentación en español y buenas traducciones.

2. Si se tienen buenos fundamentos del lenguaje java es fácil migrar de lenguaje debido a que es java el lenguaje predilecto con que se programa Android salvo algunas excepciones.En mi caso me pareció hasta cierto punto fácil.

3. La segunda parte del proyecto me costó trabajo entenderla a veces me confundía con lo que me pedía el profesor pero platicando y cometiendo errores y corrigiendolos sobre la marcha se pudo sacar el proyecto adelante.

4. Adquirí conocimientos nuevos y en este tiempo estuve del lado de la investigación me hice autodidacta y más disciplinado.

5. Por último y más importante es que pude ver como Android y en general el proyecto, juntó muchos de mis conocimientos aprendidos a lo largo de mi carrera y eso me gusto mucho utilicé mis conocimientos en: programación en general , lenguaje java (como mencioné antes la mayoria del código para android se genera en este lenguaje),XML (todas las activities son archivos XML),Estadística(calibración del dispositivo por medio de estadisticas relacionadas a varios ensayos en la velocidad),Cálculo diferencial(Derivada en proyecto 2).Vi como todos estos conocimientos se conjuntaron y les vi útilidad práctica y aplicada a las nuevas tecnologias.

Glosario

Cola circular:

Una cola circular o anillo es una estructura de datos en la que los elementos están de forma circular y cada elemento tiene un sucesor y un predecesor. Los elementos pueden cosultarse, añadirse y

eliminarse únicamente desde la cabeza del anillo que es una posición distinguida. Existen dos operaciones de rotaciones, una en cada sentido, de manera que la cabeza del anillo pasa a ser el elemento sucesor, o el predecesor, respectivamente, de la cabeza actual.

Intent:

Un intent sirve para invocar componentes, en Android entendemos por componentes las activities, Que son componentes de UI (Interfaz gráfica), services, Código ejecutándose en segundo plano, broadcast receivers, Código que responde a un mensaje de transmisión (Broadcast messages) y proveedores de contenido, código que abstráe los datos.

(20)

Sqlite:

SQLite es un sistema de gestión de bases de datos relacional .es un proyecto de dominio público creado por D. Richard Hipp.

Filtro pasa bajo:

Los filtros pasa bajo se llaman así por que solo dejan pasar la parte baja de la frecuencia.

Filtro pasa alto:

Los filtros pasa alto son aquellos que sólo dejan pasar frecuencias superiores a un cierto valor específico.

Bibliografía

http://senales.galeon.com/aficiones1349723.html http://es.wikipedia.org/wiki/SQLite

http://elbauldelprogramador.com/opensource/programacion-android-intents-conceptos/

http://es.wikipedia.org/wiki/Cola_circular

http://www.maestrosdelweb.com/editorial/curso-android-sensores-trabajar-con-acelerometro/

http://developer.android.com/tools/debugging/ddms.html http://www.javaya.com.ar/androidya

http://es.wikipedia.org/wiki/Android

http://www.webprogramo.com/instalar-android-sdk/

http://www.sgoliver.net/blog/?p=1387