Manual aplicaciones mobiles

Aplicaciones Móviles
Juan Carlos Vargas IbáñezJuan Carlos Vargas Ibáñez
Grupo: 402Grupo: 402
Rene Domínguez EscalonaRene Domínguez Escalona
ProfesorProfesor

Índice
Hola mundo ……………………………………………………………………………………3
Operaciones……………………………………………………………………………………7
Imc………………………………………………………………………………………………11
Factorial………………………………………………………………………………………...14
AlbumDroid………………………………………………………………………………..……17
Color Hex…………………………………………………………………………………..…...21
Reboso Droid…………………………………………………………………………………..25
Phone gap…………………………………………….………………………………………..29
TabHost…………………………………..…………………………………………………….30
Canvas………………...………………………………………………………………………..33
Notifications…………...……………………………………………………………………….36
RadioButton………...………………………………………………………………………….39
Date Picker……………………………………………………………………………………..43
Time Picker……………………………………………………………………………………..45
VideoView…………………………………..…………………………………………………..49
Togglebutton…………………………………..……………………………………………….51
CheckBox…………………………………..…………………………………………………..54
Spinner…………………………………..……………………………………………………..58
Acelerómetro…………………………………..……………………………………………….60
ListView…………………………………..……………………………………………………..66

Hola Mundo
Esta aplicación trata de mostrar el famoso mensaje “Hola mundo”, comencemos.
1-Lo primero que haremos será crear una nueva aplicación android, daremos file, new,
android Applicaction y nos aparecerá este recuadro
Le pondremos en “Application Name” el nombre de nuestra aplicación, en este caso
será Hola mundo. Oprimiremos Next repetidamente y por ultimo de daremos finish.

Una vez hecho lo anterior se creara la siguiente vista:
En ella podemos observar que su lleva un nombre en la barra superior de la imagen,
llamada MainActivity, y a su lado otra llamada activity_main.xml.
Estas dos pestañas nos sirven para poder programar en android. En el MainActivity se
programa el código Java y en el activity_main.xml se crea la interfaz gráfica.

Vista de activity_main.xml
En esta sección existen dos sub pestañas, Graphical Layout y activitymain.xml, se
podría decir que estas pestañas son lo mismo solo que en una se muesta en forma de
código y en la otra en forma grafica.

En este ejemplo de Hola mundo lo único que se tiene que cambiar es el TextView
Para que muestre el hola mundo y poner una imagen de fondo. Para hacer esto lo que
se tiene que hacer es lo siguiente:
Escribir la línea de código android:background="@drawable/xd". Cabe destacar que xd es
el nombre un imagen que se guarda en la siguiente dirección:
workspacenombreproyectoresdrawable-mdpinombreimagen
Y para poner Hola mundo se tiene que sustituir lo que viene por defecto en el
“android:text=” y cambiarlo por android:text=”android:tex=’Hola mundo’ ”.

Operaciones
Esta aplicación trata de mostrar las operaciones de suma, resta, multiplicación y
división, mostrándolas en un TextView. Para hacerlo Creamos un nuevo proyecto
android.

Lo primero que haremos será modificar el activity_main.xml agregándole las siguientes
características como EditText, Botones, y TextView.

Recordemos que un TextView sirve para poder mostrar texto, en este caso la línea
Android:text= ”” está vacía para que al ejecutar el código java se muestren las
operaciones. Además de eso un Button es un botón que es solo funcional si se
programan las funciones de dicho botón en un código java, Por último cabe destacar
que un TextView es aquello que nos permite insertar datos en nuestro dispositivo, es decir una caja.
A continuación se muestra el Graphical Layout que interpretan estas líneas.
La primera flecha indica un EditText, la segunda un Button y la tercera flecha un
TextView.

Nos pasamos al código java y escribimos lo siguiente, Declaramos las variables según
su tipo en el primer paso, en el segundo paso implementamos el método
OnclickListener y por ultimo mandamos a llamar el activity_main y asignamos variables.
Por último el siguiente código nos permite hacer las operaciones necesarias para poder
Efectuar el objetivo de la aplicación:

Se utiliza: switch (v.getId()){ } en caso de que apriete uno de los botones de borrar o
calcular se efectué su respectivo código. Por medio de un .getText ().toString (); se
convierte el contenido del EditText a un valor tipo String, además de que con un
Integer.parseInt(String); se convierte a Float el valor tipo String. Por ultimo por medio
de .setText() se imprime un el resultado de las operaciones en el TextView

Índice de Masa Corporal
Esta aplicación te permite por medio de cálculos programados en java hacerte saber tu
índice de masa corporal introduciendo los datos de altura y peso.
android Aplicación y nos aparecerá este recuadro
Pondremos el nombre de nuestra aplicación y el paquete. Una vez hecho se tendrá que
darle siguiente a todo hasta finalizar. Una vez creado el proyecto se modifica el la
interfaz gráfica.

Se crean dos EditText así como dos botones y un TextView, con sus respectivos id’s
(“altura, peso, talla, calcular, borrar, resultado”). Además de ser alineados dentro del
LinearLayout verticalmente y poner un Backgroud. Su aspecto en el Graphical es el
anterior.

El código java es el siguiente:
En la primera imagen se declaran las variables tipo Button, TextView y EditText,
además de crearse implementarse el método OnClickListener.

En la siguiente imagen dentro del método OnClick se crea un switch el cual según el
botón que presionemos se accionara una serie de código, en caso de que se apriete
calcular se harán las operaciones correspondientes al cálculo del Imc, y en caso de
que presione borrar se limpiaran los EditText y los TextView. Podemos ver funcionando
el código en la siguiente imagen.
Factorial
Esta aplicación te permite por medio de cálculos programados en java hacerte la
factorial de un número cualquiera, debido a esto es casi código Java.

interfaz gráfica.

Se crean un EditText así como dos botones y un TextView, con sus respectivos id’s
(“a, factorial, borrar, resultado”). Además de ser alineados dentro del LinearLayout
verticalmente y poner un Backgroud. Su aspecto en el Graphical es el anterior.

En la primera imagen se declaran las variables tipo Button, TextView y EditText,
además de crearse implementarse el método OnClickListener.
botón que presionemos se accionara una serie de código, en caso de que se apriete
Factorial lo primero que hará será compara si lo que introducimos al EditText es igual a
uno o dos o si en caso que sea mayor que dos se iniciara un for que nos permitirá
calcular el factorial de dicho numero por medio de una condición hasta sacar el factor,
y en caso de que presione borrar se limpiaran los EditText y los TextView. Podemos
ver el resultado del código en la siguiente imagen.

AlbumDroid
Esta aplicación te permite por medio de su interfaz gráfica elegir un Wallpaper y
ponerlo como fondo.

Se crean un ImageView así como debajo de este un LinearLayout y un
HorizontalScrollView, dentro de estos se ponen otros ImageView que son mas
pequeños y con la ayuda del LinearLayout y HorizontalScrollView se deslicen las
imágenes, con sus respectivos id’s (“a, b, c, d”). Además de ser alineados dentro del
LinearLayout verticalmente y poner un Backgroud negro. Su aspecto en el Graphical es
el anterior.

En la primera imagen se declaran las variables tipo ImageView, Button, además de
crearse e implementarse el método OnClickListener.
botón que presionemos se accionara una serie de código; en caso de que presione un
ImageView este se mostrara en el ImageView superior y así sucesivamente, en caso
de que presione el botón cambiar este por medio de un Toast informara que se ha
cambiado el Wallpaper por medio del código en pantalla. Además esta aplicación
necesita permisos especiales para poder hacer esto, por medio del siguiente código se
puede cambiar el Wallpaper, esto va en el android manifest.
Por último el resultado de la aplicación:

ColorHex
Esta aplicación te permite por medio de la numeración Hexadecimal cambiar el color de
un EditText que actúa como un fondo
interfaz gráfica.

Se crean un LinearLayout así como adentro de este dos TextView, debajo del
LinearLayout se crea otro que contenga un SeekBar que es lo que dará los colores

Además de ser alineados dentro del LinearLayout verticalmente y poner un Backgroud
de una moto. Su aspecto en el Graphical es el anterior. Cabe destacar que esto solo es
una parte del código completo.

En la primera imagen se declaran las variables tipo TextView, SeekBar, además de
crearse e implementarse el método OnSeekBarChangeListener
En la siguiente imagen dentro del método onProgressChanged se crea un switch el
cual según por medio del avance del SeekBar se registrara dentro de tres variable tipo
int. Tenemos que el siguiente método String ColorHex se convierte este progreso en
Hexadecimal y por último se registra esto y se manda el avance ya convertido en
Hexadecimal y se crean los colores, además los métodos onStartTrackingTouch y
onStopTrackingTouch permiten saber en dónde se inicia y termina el deslice.

RebosoDroid
Esta aplicación te permite intercambiar datos entre Activitys, en el ejemplo de esta
aplicación se ingresa un nombre y se le da la bienvenida en el otro Activity
interfaz gráfica.

Existen dos Activitys, dentro de la primera se encuentra un EditText y un Button y en
la otra dos TextView. Además de ser alineados dentro del LinearLayout verticalmente y
poner un Backgroud de un color negro y amarillo respectivamente. Su aspecto en el
Graphical son los anteriores.

Código Java:
Activity 1: En esta se declaran las variables tipo EditText, Button, además de crearse e
implementarse el método OnClickListener.
Dentro del método OnClick se crea un switch el cual cuando se toca el botón
inmediatamente se activa el código Intent el cual te envía a la otra actividad llevando
consigo la variable String donde se guardó lo introducido en el EditText.
Activity 2: Se declaran las variables tipo EditText. Se recibe el nombre por medio del
código en pantalla y se imprime en el EditText por medio del .setText.

Phone Gap
Esta aplicación no requiere de código Java para su funcionamiento por lo tanto lo único
que se tiene que hacer es crear una carpeta llamada www y colocarla en la carpeta
assets. Dentro de la carpeta www se guardan las paginas HTML por lo tanto solo se
requiere conocimientos de HTML.

TabHost
Esta aplicación te permite tener un TabHost es decir algo así como un menú en el cual
te puedes desplazar y tener más espacio de trabajo.

Existen un TabHost, dentro de esta se encuentra un LinearLayout, dentro de la cual
hay un TabWidget y un FrameLayout, que esta a su vez tiene 2 linear Layout que tiene
el contenido de cada TabHost, dentro ambos hay imágenes. Además de ser alineados
dentro del LinearLayout verticalmente.
Su aspecto en el Graphical es el siguiente.
Código Java:
En este Activity se declara el TabHost y a su vez las pestañas y el nombre de cada 1,
como arriba se muestra. Aplicación Terminada:

Canvas
Esta aplicación te permite dibujar en un lienzo algunas figuras como cuadrados,
círculos y rectángulos.
1-Lo primero que haremos será crear una nueva aplicación android, daremos clic
En file, new, android Aplicación y nos aparecerá este recuadro

darle siguiente a todo hasta finalizar.
Lo primero que haremos será crear un archivo llamado colors en la carpeta valúes,

Dentro de ese archivo colocaremos lo siguiente:
Esto nos servirá para colorear las figuras.
Abrimos el Activity y haremos lo siguiente

En la imagen de arriba tenemos que la clase Ondraw nos permitirá crear un nuevo
pincel y a este le agregaremos los colores, para eso mandamos a llamar a colors.xml
que es el lugar donde tenemos los colores. Y por último dibujamos las figuras, en el
caso del círculo:
Tenemos que el primer número indica el radio de este y los otros 2 numeros la
posición <X Y> y el pinceloo es el pincel.
En el caso de las líneas
Tenemos que los 2 primeros números indican la posición <X Y> donde inicia el punto y
los otros 2 números indican la posición <X Y> donde finaliza la línea.
El código anterior genera la siguiente figura:

Notificación
Esta App usa un botón que al ser presionado te manda una notificación la cual tiene
también consigo una imagen.
1-Lo primero que haremos será crear una nueva aplicación android, daremos clic file,
new, android Aplicación y nos aparecerá este recuadro

darle siguiente a todo hasta finalizar. Una vez creado el proyecto se modifica la interfaz
gráfica de la siguiente manera.
Lo único que pondremos será un botón, y le pondremos un fondo:

Después crearemos otro archivo XML que tendrá el siguiente código:
Solo un ImageView y un TextView.
Nos pasamos al Main_Activity y pondremos lo siguiente:

Crearemos un Método llamado triggerNotificación el cual definirá las características del
mismo. Este método mandara a llamar el archivo XML que creamos y lo utilizara como
notificación además de ser capaz de establecer la información de esta.
Enseguida con el método OnClick definiremos el tiempo de aparición de la notificación
además de mandar a llamar el método triggerNotificación el cual lanzara el XML de la
notificación.
La aplicación funcionando seria así:

RadioButton
Esta aplicación te da a escoger quien es el mejor jugador del mundo para ti, lo hace
con un radio Button.

Se crea un radio grup con las siguientes características

Colocamos una imagen de fondo y el Graphical Layout se vería así:

Primero implementamos el método OnCheckedChangeListener y declaramos el radio
Button y el RadioGrup, después inicializamos las variables. Hecho lo anterior utilizamos
el método OnCheckedChangeListener y ponemos 3 condiciones tipo if por cada radio
Button, al tocar cualquier opción está de acuerdo a su if te llevara a otra Activity.
Vista Final:

Date Picker
Esta aplicación es como un calendario que te permitirá consultar fechas

Se escribe el código de esta manera, solo un botón y un Date Picker
Después se escribe el código java:
Se inicializan y declaran las variables tipo Date Picker y Button, dentro del método
OnClick se pone un Toast que muestra la fecha escogida.
La aplicación se vería así:

Time Picker
Esta aplicación es un reloj, en este ejemplo te permitirá cambiar el horario de 24 horas
a un cómodo y fácil de entender de 12 horas.

Se escribe el código de esta manera, solo un botón, un TextView y un Time Picker
Después se escribe el código java:

Se inicializan y declaran las variables tipo Time Picker y Button, dentro del método
OnClick se pone un Toast en el que se cambian las horas de 24 a 12.
La aplicación se vería así:

VideoView
Esta aplicación es un video, en este ejemplo podrás ver el video de la canción de
Dragón Ball
gráfica de la siguiente manera. Además de crear un carpeta llamada raw en el
directorio workspaceVideoViewresraw. Y poner un video con formado MP4.

Se escribe el código que se puede observar el pantalla:
<VideoView
android:id="@+id/videoView_video"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:layout_alignParentTop="true"
android:layout_centerInParent="true" />
Podemos notar que es solo un VideoView en el XML.
Después escribiremos el siguiente código que nos permitirá reproducir el video en el código Java:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
VideoView videoView = (VideoView) findViewById(R.id.videoView_video);
Uri path =Uri.parse("android.resource://com.example.reproducirvideo/"+
R.raw.dbz);
videoView.setVideoURI(path);
videoView.start();
}
Primero se declara la variable VideoView y después se manda a llamar el video por el código de
Uri path =Uri.parse("android.resource://com.example.reproducirvideo/"+
R.raw.dbz);
En el cual cabe destacar que es llamado por el nombre. Y por ultimo se inicia el video con el código:
VideoView.start();
Debido a que en el emulador de Android no funcionan los videos no podre mostrar la imagen de la
aplicación final terminada.

ToggleButton
Esta aplicación es un botón que al presionarlo una vez este actúa como un on que se
detendrá al oprimir el botón de nuevo cambiando al estado de off.

<ToggleButton
android:id="@+id/toggleButton1"
android:text="ToggleButton" />
<ToggleButton
android:id="@+id/toggleButton2"
android:textOn="@string/toggle_turn_on"
android:textOff="@string/toggle_turn_off"
android:checked="true" />
<Button
android:id="@+id/btnDisplay"
android:text="@string/btn_display" />
La interfaz está compuesta por dos Togglebutton y un botón que al ser presionado este
te indicara por medio de un toast si esta encendido o apagado cada Togglebutton.
Tenemos que el código java es el siguiente:
private ToggleButton toggleButton1, toggleButton2;
private Button btnDisplay;
Tenemos que primero declaramos 2 Togglebutton y un boton
@Override
public void onCreate(Bundle savedInstanceState) {
setContentView(R.layout.main);
addListenerOnButton();
}
public void addListenerOnButton() {
toggleButton1 = (ToggleButton) findViewById(R.id.toggleButton1);
toggleButton2 = (ToggleButton) findViewById(R.id.toggleButton2);
btnDisplay = (Button) findViewById(R.id.btnDisplay);
btnDisplay.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
StringBuffer result = new StringBuffer();
result.append("toggleButton1 : ").append(
toggleButton1.getText());
result.append("ntoggleButton2 : ").append(
toggleButton2.getText());
Toast.makeText(MyAndroidAppActivity.this,
result.toString(),
Toast.LENGTH_SHORT).show();

}
});
}
Inicializamos las variables y por el método OnClickListener del botón se abre un
método el cual te imprime por medio de un toast el estado del botón.
Podemos ver la aplicación en funcionamiento.

CheckBox
Esta aplicación que te permite escoger varias opciones a la vez, que en diferencia del
radio Button que solo toma en cuenta una opción.
1-Lo primero que haremos será crear una nueva aplicación Android, daremos clic file,
new, Android Aplicación y nos aparecerá este recuadro

<TextView
android:id="@+id/textView1"
android:layout_alignParentLeft="true"
android:text="Ingrese valor 1:" />
<EditText
android:id="@+id/et1"
android:layout_below="@+id/textView1"
android:ems="10" >
<requestFocus />
</EditText>
<TextView
android:id="@+id/textView2"
android:layout_below="@+id/et1"
android:text="Ingrese valor 2:" />
<EditText
android:id="@+id/et2"
android:layout_below="@+id/textView2"
android:ems="10" />
<CheckBox
android:id="@+id/checkBox1"
android:layout_below="@+id/et2"
android:text="Sumar" />
<CheckBox
android:id="@+id/checkBox2"
android:layout_below="@+id/checkBox1"
android:text="Restar" />
<Button
android:id="@+id/button1"

android:layout_below="@+id/checkBox2"
android:onClick="operar"
android:text="Calcular" />
<TextView
android:id="@+id/tv3"
android:layout_below="@+id/button1"
android:text="resultado" />
Como podemos notar en el código se trata de 2 EditText y 3 TextView además de un
botón y un CheckBox
Quedando un Graphical Layout:
private EditText et1,et2;
private TextView tv3;
private CheckBox checkBox1,checkBox2;
@Override
setContentView(R.layout.activity_main);

et1=(EditText)findViewById(R.id.et1);
et2=(EditText)findViewById(R.id.et2);
tv3=(TextView)findViewById(R.id.tv3);
checkBox1=(CheckBox)findViewById(R.id.checkBox1);
checkBox2=(CheckBox)findViewById(R.id.checkBox2);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
//Este método se ejecutará cuando se presione el botón
public void operar(View view) {
String valor1=et1.getText().toString();
String valor2=et2.getText().toString();
int nro1=Integer.parseInt(valor1);
int nro2=Integer.parseInt(valor2);
String resu="";
if (checkBox1.isChecked()==true) {
int suma=nro1+nro2;
resu="La suma es: "+ suma;
}
if (checkBox2.isChecked()==true) {
int resta=nro1-nro2;
resu=resu + " La resta es: "+ resta;
}
tv3.setText(resu);
}
Lo primero que se hace es crear e inicializar las variables, una vez inicializadas con el
método Operar que se activa al pulsar el botón se convierten lo contenido en los
EditText en String y estas a su vez en Int. Y por medio de un if se checa si algún
CheckBox está activado o no, si está activado se hacer su respectiva operación y por
último se imprime el resultado en un TextView.
La aplicación es así:

Spinner
Esta aplicación que te permite escoger una opción en forma de lista desplegable la cual
ocupa poco espacio.

<TextView
android:layout_width="fill_parent"
android:layout_marginTop="10dip"
android:text="Categoria:"
android:layout_marginBottom="5dp"
/>
<Spinner
android:id="@+id/spinner"

android:layout_width="fill_parent"
android:prompt="@string/spinner_title"
/>
Como se podrán observar este código XML está compuesto únicamente por un Spinner
y un TextView, así es su aspecto en el Graphical Layout:
Su código java es el siguiente:
public class AndroidSpinnerExampleActivity extends Activity implements
OnItemSelectedListener{
@Override
Spinner spinner = (Spinner) findViewById(R.id.spinner);
spinner.setOnItemSelectedListener(this);
List<String> categories = new ArrayList<String>();
categories.add("Automobile");
categories.add("Servicios de negocios");
categories.add("Computadoras");
categories.add("Educacion");
categories.add("Personal");
categories.add("Viajes");
// adaptador para spinner
ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>(this,
android.R.layout.simple_spinner_item, categories);
//Diseño de la lista
dataAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
// adjuntando datos adaptador para spinner
spinner.setAdapter(dataAdapter);
}
@Override

public void onItemSelected(AdapterView<?> parent, View view, int position,
long id) {
// Seleccionamos el item
String item = parent.getItemAtPosition(position).toString();
// Showing selected spinner item
Toast.makeText(parent.getContext(), "Selected: " + item,
Toast.LENGTH_LONG).show();
}
public void onNothingSelected(AdapterView<?> arg0) {
// TODO Auto-generated method stub
}
Lo primero que se hace es declarar el Spinner y este se inicializa, para después
añadirse e implementar OnItemSelectedListener. Después se crea la lista desplegable
de los servicios, para después adaptar la lista al Spinner y adjuntarla además de crear
la forma de un Radio Button. Por último en el método onItemSelected al ser escogido
el ítem este método guarda el nombre del ítem para después imprimirlo en un toast.
Imagen de la aplicación terminada:
Acelerómetro
Esta aplicación que te permitirá conocer y utilizar el acelerómetro de tu teléfono
además de saber las posiciones x y z de tu teléfono conforme lo muevas

<TextView
android:id="@+id/sensorNameLabel"

android:text="@string/sensorNameLabel" />
<TextView
android:id="@+id/sensorNameValue"
android:layout_alignTop="@id/sensorNameLabel"
android:layout_toRightOf="@id/sensorNameLabel" />
<TextView
android:id="@+id/sensorVendorLabel"
android:layout_below="@id/sensorNameLabel"
android:text="@string/sensorVendorLabel" />
<TextView
android:id="@+id/sensorVendorValue"
android:layout_alignTop="@id/sensorVendorLabel"
android:layout_toRightOf="@id/sensorVendorLabel" />
<TextView
android:id="@+id/sensorVersionLabel"
android:layout_below="@id/sensorVendorLabel"
android:text="@string/sensorVersionLabel" />
<TextView
android:id="@+id/sensorVersionValue"
android:layout_alignTop="@id/sensorVersionLabel"
android:layout_toRightOf="@id/sensorVersionLabel" />
<TextView
android:id="@+id/sensorPowerLabel"
android:layout_below="@id/sensorVersionLabel"
android:text="@string/sensorPowerLabel" />
<TextView
android:id="@+id/sensorPowerValue"
android:layout_alignTop="@id/sensorPowerLabel"
android:layout_toRightOf="@id/sensorPowerLabel" />
<TextView
android:id="@+id/labelX"
android:layout_below="@id/sensorPowerLabel"

android:text="@string/Ejex" />
<TextView
android:id="@+id/valueX"
android:layout_alignTop="@id/labelX"
android:layout_marginLeft="5dp"
android:layout_toRightOf="@id/labelX" />
<TextView
android:id="@+id/labelY"
android:layout_below="@id/labelX"
android:text="@string/Ejey" />
<TextView
android:id="@+id/valueY"
android:layout_alignTop="@id/labelY"
android:layout_toRightOf="@id/labelY" />
<TextView
android:id="@+id/labelZ"
android:layout_below="@id/labelY"
android:text="@string/Ejez" />
<TextView
android:id="@+id/valueZ"
android:layout_alignTop="@id/labelZ"
android:layout_toRightOf="@id/labelZ" />
Como se podrá ver solo son necesarios Text View.
En el código java:
@Override
setContentView(R.layout.activity_sensor);
tvSensorValue = (TextView) findViewById(R.id.sensorNameValue);
tvVendorValue = (TextView) findViewById(R.id.sensorVendorValue);
tvVersionValue = (TextView) findViewById(R.id.sensorVersionValue);
tvPowerValue = (TextView) findViewById(R.id.sensorPowerValue);
tvValueX = (TextView) findViewById(R.id.valueX);
tvValueY = (TextView) findViewById(R.id.valueY);
tvValueZ = (TextView) findViewById(R.id.valueZ);

mSensor = (SensorManager) getSystemService(SENSOR_SERVICE);
mSensor.registerListener(this,
mSensor.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
SensorManager.SENSOR_DELAY_UI);
mostrarInformacion();
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
@Override
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
refreshValues(event);
}
}
private void mostrarInformacion() {
// List<Sensor> sensorList =
// mSensor.getSensorList(Sensor.TYPE_ACCELEROMETER);
Sensor sensor = mSensor.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
tvSensorValue.setText(sensor.getName());
tvVendorValue.setText(sensor.getVendor());
tvVersionValue.setText(String.valueOf(sensor.getVersion()));
tvPowerValue.setText(String.valueOf(sensor.getPower()));
}
private void refreshValues(SensorEvent event) {
float values[] = event.values;
float x = values[0];
float y = values[1];
float z = values[2];
tvValueX.setText(String.valueOf(x));
Log.i("refreshValues", "Valor del Eje X: " + String.valueOf(x));
tvValueY.setText(String.valueOf(y));
Log.i("refreshValues", "Valor del Eje Y: " + String.valueOf(y));
tvValueZ.setText(String.valueOf(z));
Log.i("refreshValues", "Valor del Eje Z: " + String.valueOf(z));
}
@Override
protected void onPause() {
super.onPause();
mSensor.unregisterListener(this);
}
@Override
protected void onResume() {
super.onResume();
mSensor.registerListener(this,

mSensor.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
SensorManager.SENSOR_DELAY_UI);
}
Podemos ver que tenemos la clase SensorManager como variable de instancia. Esta
clase nos permitirá acceder a los sensores del sistema.
El método PROTECTED VOID ON CREATE() permite inicializar todos los
componentes de la aplicación. Se instancian los TextView necesarios para luego
establecerle unos valores y además instanciar también la clase SensorManager para
poder obtener información y tener acceso a los sensores del sistema
.
La parte mas importante para poder recaudar información sobre el Acelerómetro en
este caso, es en la que definimos un Listener en el SensorManager. Se registra
un listener el cuál acepta como parámetros elContext de nuestra Activity, el sensor que
queremos registrar, y una constante que recaudará los datos a una velocidad
determinada.
El metodo public void mostrar informacion() se encargará de establecer en
nuestros TextView el nombre del sensor asi como los datos relacionados a este.
El método public void onSensorChanged(SensorEvent event)
Se encargara, que en caso de un cambio del valor del sensor, que refrescara los
valores referentes a los ejes x y z. A continuación se extraerán del array cada valor a
una variable del tipo float y a continuación los establecemos en
suTextView correspondiente.
Captura de pantalla de la aplicación:
ListView

Esta aplicación te permitirá conocer y utilizar las listas que enrealidad son mas que
unos elementos que muestran items verticalmente en una lista con scroll, para poder ir
moviendonos hacia abajo y ver todos los elementos.
<ListView

android:id="@+id/listview"
android:layout_height="wrap_content"/>
Como podrán ver este código nos permitirá apreciar una lista en el Graphical así:
El código Java seria así:
private ListView list;
private String[] sistemas = {"Ubuntu", "Android", "iOS", "Windows", "Mac OSX",
"Google Chrome OS", "Debian", "Mandriva",
"Solaris", "Unix"};
list = (ListView)findViewById(R.id.listview);
ArrayAdapter<String> adaptador = new ArrayAdapter<String>(this,
android.R.layout.simple_list_item_1, sistemas);
list.setAdapter(adaptador);
list.setOnItemClickListener(new OnItemClickListener(){
@Override
public void onItemClick(AdapterView<?> arg0, View arg1, int position,
long id) {
Toast.makeText(getApplicationContext(), "Ha pulsado el item " +
position, Toast.LENGTH_SHORT).show();
}
});
Creamos un Array en sonde se guardaría la lista, después de eso se inicializa el
ListView, después vamos a declarar el Adapter. Esta clase será la encargada de

adaptar el Array que tenemos a un ListView. En este caso, el adapter será solo de ya
que nuestro array solo contiene elementos de tipo String.
Por último estableceremos el objeto adapter de la clase ArrayAdapter al ListView que
hemos declarado, agregar un listener a la lista, en este caso un onItemClickListener,
que producirá un aviso mediante un objeto Toast con el número del elemento pulsado
cuando pulsemos sobre la ListView. A continuación, creamos un Toast, el cual
mostrará un aviso que nos devolverá el elemento que hemos pulsado.
Aplicación:

Manual aplicaciones mobiles

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (15)

Similar a Manual aplicaciones mobiles

Similar a Manual aplicaciones mobiles (20)

Último

Último (20)

Manual aplicaciones mobiles