Manual de aplicaciones moviles

MANUAL DE APLICACIONES MOVILES EN
ANDROID STUDIO
&
ECLIPSE
VAZQUEZ VEL AZQUEZ JORGE JAEL
403

1
INDICE
Introducción 3
Hola Mundo 4-5
Time picker 6-8
Date picker 9-10
Radio Button 11-12
Check Button 13-14
Gallery 15-18
Calculadora 19-22
Acelerómetro 23-24
Toggle Button 25-27
Sonidos 28-29
Giroscopio 30-32
Progress Bar 33-34
Spinner 35-38
List View 39-40
Piano 41
Web View 42-43
Video View 43-44
Tab Host 44-46
Widget 47-48
Notificaciones 49-50
Calcular Edad 50-52
Cámara 52-53
Base de Datos 54-55
Eliminar BD 55-56
Canvas 56-58

2
INTRODUCCION
En este tutorial veremos cómo podemos crear desde una simple aplicación hasta
una aplicación más complicada pero antes de todo veremos algunos términos que
utilizaremos en este manual solo serán unos cuantos ósea los más
fundamentales.
Empezaremos con algunos términos de nuestro XML que es donde tendremos
nuestra interfaz grafica:
Mach parent: esto quiere decir que se acomodara dependiendo del espacio que
tengamos.
Layout Height: Esta se refiere a las dimensiones de la altura.
Layout Widht: Esta se refiere a las dimensiones de la anchura.
Android ID: Este será el nombre de nuestro botón texto o cualquier otra
herramienta utilizada con el que la reconoceremos.
Estos son los básicos o le mayor importancia .
Ahora es importante saber que cuando tu generes por primera vez un proyecto
tendrás que generar una contraseña con la cual podrás exportar tus proyectos a
APK después contaras con dos formularios el XML y JAVA como lo mencionare
en la elaboración de los programas en nuestro XML ira la parte GRAFICA y en el
JAVA nuestra parte lógica del programa.
Ahora estás listo o tienes los conocimientos previos para que puedas empezar y
entender de una manera más factible los siguientes proyectos y elaborarlos a tu
manera.

3
APLIACION 1: HOLA MUNDO
Para crear un hola mundo en android necesitaremos tener instalados eclipse y
luego el plugin de android.
Crearemos un nuevo proyecto android y luego rellenaremos los campos nombre
del proyecto, nombre de la aplicación, package name y escogeremos que es para
la versión 1.5 de android.
Por consecuencia nos creará varios archivos, pero el que nos importa es el que
está dentro de src/cristalab.com. Al abrirlo veremos que tenemos el siguiente
código:
Código:
package jorgeva.com;
import android.app.Activity;
import android.os.Bundle;
public class HolaMundo extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Ahora simplemente debemos cambiar unas líneas de código. Sustituimos la línea
setContentView... por
Código :
TextView tv = new TextView(this);
tv.setText("Hola Mundo");

4
Con esto creamos un campo de texto y lo inicializamos con el texto "Hola Mundo"
y luego hacemos que aparezca por pantalla. Veremos que eclipse nos dice que
nos falta importar una clase, para ello usamos la ayuda de eclipse y apretamos
Ctrl+Shift+o y nos añadirá" import android.widget.TextView;"
Por lo que el código final será:
Código :
package jorgeva.com;
import android.widget.TextView;
public class HolaMundo extends Activity {
/** Called when the activity is first created. */
@Override
TextView tv = new TextView(this);
tv.setText("Hola Mundo");
setContentView(tv);
}
}
Ya tenemos lista nuestra primera aplicación en android. Para ejecutarla en el
emulador simplemente elegimos el menú Run->Run->Android Application. Con
esto nos saltará el emulador.

5
APLIACION 2: Time Picker
para crear esta aplicación debemos ir a la pestaña de XML e insertar el siguiente
código como lo muestra a continuacion
El TextView será el que almacenará el valor de la hora seleccionada. El botón será
el que lanzará el TimePicker cuando se pulse.
Estas son las librerías que utilizaremos para crear la APP:
import android.widget.Button;
import java.util.Calendar;
import android.view.View;
import android.app.TimePickerDialog;
import android.widget.TimePicker;
import android.app.Dialog;

Para poder agregar ahora las siguientes variables a la misma clase:
private TextView mTimeDisplay;
private Button mPickTime;
private int mHour;
private int mMinute;
static final int TIME_DIALOG_ID = 0;
Ahora vamos a modificar el código OnCreate de la siguiente forma:
6
En el método OnCreate, hacemos que la variable mTimeDisplay haga referencia al
TextView donde se mostrará la hora. Y la variable mPickTime haga referencia al
botón que se pulsará para lanzar el TimePicker. También indicamos que al
pulsarse se llamará a showDialog() pasándole un identificador para identificar el
TimePicker que se quiere utilizar. Y por último se lee la hora actual y se guarda en
las variables mHour y mMinute para mostrarlas en el método updateDisplay() en el
TextView.
Ahora vamos a añadir el código del método updateDisplay() que básicamente lee
los valores de la hora almacenados en nHour y mMinute y los guarda en el
TextView en formato hh:mm.

El método pad lo único que hace es poner un cero por la izquierda si la hora o los
minutos son menores de 10.
7
A continuación, agregamos a la clase un TimePickerDialog.OnTimeSetListener
cuando el usuario seleccione la hora en el TiemPickerDialog. Al hacerlo, se
actualizarán los valores de las variables Hour y Minute con el valor seleccionado
por el usuario y se llamará a updateDisplay() para que se actualice el valor del
TextView.
Y a continuación, definimos lo que se hará cuando se llame a showDialog
agregando el método onCreateDialog. Cuando se llame a showDialog y se pase el
identificador de nuestro TimePicker, se abrirá un nuevo TimePickerDialog al que
se le pasará el objeto mTimeSetListerner que acabamos de crear, la variable
mHour y mMinute. El último parámetro (false) es para indicar si el formato es de
24 horas o no (cuenta solo hasta 12).
Este es todo el código que necesitamos para elaborarlo después lo podemos
probar en el emulador como le explique en la app anterior.

8
APLIACION 3: Date Picker
En esta Aplicacion, crearemos una aplicación que contendrá un widget
DatePicker.
Este widget permite seleccionar una fecha (día, mes y año) de una forma cómoda
y con un interfaz con el que los usuarios ya están familiarizados.
En un LinearLayout, colocaremos un TextView que mostrará la fecha y un botón
para abrir el DatePickerDialog.
Ahora deberemos agregar las siguientes librerías para poder hacer el siguiente
cambio:
Aquí se muestran los campos que tendremos que agregar en nuestra interfaz
grafica :
private TextView mDateDisplay;
private Button mPickDate;
private int mYear;
private int mMonth;
private int mDay;
static final int DATE_DIALOG_ID = 0;
Las primeras variables son para definir los controles y los campos de la fecha.
El DATE_DIALOG_ID se utiliza para identificar el datePickerDialog.

Agregamos el siguiente código al método OnCreate():
9
Después vamos a colocar la lógica del método updateDisplay():
Este método convierte una fecha a formato cadena de texto con el formato “mm-
dd-yyyy” (mes-día-año) y lo guarda en el control TextView.
A continuación tenemos que agregar método onCreateDialog(int) en la clase HelloDatePicker:
Este método se ejecuta cuando se llama al showDialog(DATE_DIALOG_ID) dentro del
OnClickListener.
En esta aplicación Podemos elegir la hora que deseemos de una forma muy simple en la cual
después de haber elegido la hora le damos en change y por consecuencia se cambia l hora
solicitada.

10
APLIACION 4: Radio Button.
Como todas las apliaciones tenmos que crear nuestra Nueva Aplicación de Android en este
Caso al de Radio Button,
Despues de a ver creado la apliacion debemos de poner nuestro grupo de button en cual lo
encontraresmo en FORM WIDGETS. Esto es sencillo solo tenemos que jalar hacia nuestra
interfaz grafica y se generaran automáticamente 3 botones.
A continuación el Codigo Java:
import android.view.Menu;
import android.widget.EditText;
import android.widget.RadioButton;
public class MainActivity extends Activity {
private EditText et1,et2;
private TextView tv3;
private RadioButton r1,r2;
@Override
protected void onCreate(Bundle savedInstanceState) {
setContentView(R.layout.activity_main);
et1=(EditText)findViewById(R.id.et1);
tv3=(TextView)findViewById(R.id.tv3);
r1=(RadioButton)findViewById(R.id.r1);

}
@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;
}
11
//Este método se ejecutará cuando se presione el botón
public void operar(View view) {
String valor1=et1.getText().toString();
int nro1=Integer.parseInt(valor1);
if (r1.isChecked()==true) {
int suma=nro1+nro2;
String resu=String.valueOf(suma);
tv3.setText(resu);
} else
int resta=nro1-nro2;
String resu=String.valueOf(resta);
tv3.setText(resu);
} } }
A continuación mostrare como se declara los Radio:
r1 y r2 se toman como el id de nuestros Radion Button.
Y para finalizar Mostramos Nuestro Codigo:
int suma=nro1+nro2;

tv3.setText(resu);
} else
tv3.setText(resu);
} }
Este Programa sirve para cuestionarios o en este caso lo utilizamos para la elaboración de
una calculadora la cual se selecciona atravez de Radio Button y a la vez la hace más sencilla.
12
APLIACION 5: Check Button.
Bueno Pues esta aplicación la haremos de igual manera con una calculadora para
hacer esto más breve y lo único que hare será mostrarles el código para el Check
Button.
import android.widget.CheckBox;
import android.widget.EditText;
private CheckBox checkBox1,checkBox2;
@Override
checkBox1= (CheckBox)findViewById(R.id.checkBox1);
checkBox2=(CheckBox)findViewById(R.id.checkBox2);
}
@Override

return true; }
String resu="";
13
if (checkBox1.isChecked()==true) {
int suma=nro1+nro2;
resu="La suma es: "+ suma;
}
resu=resu + " La resta es: "+ resta;
}
tv3.setText(resu);
}
}
Aquí lo único que se hara será inicializar o declara la clase CheckBox como atributos de la
clase:
private CheckBox checkBox1,checkBox2;
En el método onCreate los declaramos con los objetos definidos en el archivo
XML:
En el método operar debemos definir dos if a la misma altura ya que los dos
controles de tipo CheckBox pueden estar seleccionados simultaneamente.
Definimos una variable de tipo String y la inicializamos con cadena vacía para el
caso en que los dos CheckBox no estén seleccionados:
String resu="";
int suma=nro1+nro2;
resu="La suma es: "+ suma;

}
resu=resu + " La resta es: "+ resta;
}
tv3.setText(resu);
Pues más que nada es una forma más simple de utilizar o generar programas ya
que puedes elegir opción y no precisamente solicitar toda una respuesta como tal
si no que solo seleccionar.
14
APLIACION 6: Gallery.
A continuación Veremos cómo realizar una galería.
En esta aplicación utilizaremos lo que son 2 activities mas:
° ShowGalleryActivity y SwipelmageActitvity
Y después se crearan cuatro Layouts:
° activity_main (Se crea por defecto cuando creamos el proyecto)
images_gallery (Contiene el GridView)
show_image (Es el contenedor de la imagen original, con algunos textos de ayuda)
swipe_image_layout (Contiene el componente ViewPager, donde cargaremos el
layoutshow_image, con las imágenes originales para hacer el efecto de "swipe").
Despues de a ver creado nuestro nuevo proyecto tenemos que meter nuestras imágenes
a la carpeta src en mdpi.
A continuación ostrare el código:
public static int mSelected = 0;
private GridView gridview;
// Hacemos referencia a nuestras imagenes en miniatura de la carpeta de
recursos
public static Integer[] mImagesIds = {
R.drawable.i1_thumb, R.drawable.i2_thumb,

R.drawable.i31_thumb
};
setContentView(R.layout.images_gallery);
15
//Hacemos referncia nuestro GridView
gridview = (GridView) findViewById(R.id.gridview);
//Asignamos el ImageAdapter que hemos creado en esta misma clase al
GridView
gridview.setAdapter(new ImageAdapter(this));
//Nos movemos al elemento seleccionado del GridView
gridview.setSelection(mSelected);
}
@Override
protected void onStart() {
super.onStart();
gridview = (GridView) findViewById(R.id.gridview);
gridview.setAdapter(new ImageAdapter(this));
gridview.setSelection(mSelected);
}
@Override
getMenuInflater().inflate(R.menu.show_gallery_activity, menu);
return true;
}
//ImageAdapter para almacenar las imagemes en el GridView
public class ImageAdapter extends BaseAdapter {
private Context mContext;
public ImageAdapter(Context c) {
mContext = c;
}

public int getCount() {
return mImagesIds.length; }
public Object getItem(int position) {
return null;
}
public long getItemId(int position) {
return 0;
}
// Creamos un ImageView por cada imagen miniatura referenciada en nuestro
ImageAdapter
public View getView(final int position, View convertView, ViewGroup parent) {
ImageView imageView;
if (convertView == null) { // if it's not recycled, initialize some attributes
imageView = new ImageView(mContext);
imageView.setLayoutParams(new
GridView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 130));
16
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)
{
imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
imageView.setCropToPadding(true);
} else {
imageView.setScaleType(ImageView.ScaleType.FIT_XY);
}
imageView.setPadding(2, 2, 2, 2);
} else {
imageView = (ImageView) convertView;
}
//Asignamos a cada ImageView una imagen de nuestro "Array" de recursos
//utilizamos "setImageResource" ya que nuestras imagenes estan
almacenadas en una
//carpeta de recursos en nuestro proyecto.
// "mImagesIds" es un Array de enteros, ya que almacena el Id del recurso,
no la imagen en si.
imageView.setImageResource(mImagesIds[position]);
//En el evento click del ImageView obtenemos el indice de la imagen
seleccionada
imageView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
mSelected = (Integer) view.getTag();
notifyDataSetChanged();
String index = String.valueOf(position);
Bundle extras = new Bundle();

//Pasamos el indice de la imagen seleccionada a la activity que se encarga
de mostrar la image Original
//y hacer el "swipe"
extras.putString("position", index);
startActivity(new Intent(ShowGalleryActivity.this,
SwipeImageActivity.class).putExtras(extras).addFlags(Intent.FLAG_ACTIVITY_NE
W_TASK)); }
});
try {
imageView.setTag(position);
//Ponemos un borde de color naranja a la imagen en miniatura
seleccionada en el GrisView
if (position == mSelected) {
imageView.setBackgroundColor(Color.parseColor("#ff6203"));
} else {
imageView.setBackgroundColor(Color.TRANSPARENT);
}
}
17
catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return imageView;
} }}
En este código se muestra como nombramos y declaramos cada una de nuestras
imágenes insertadas en mdpi.A continuación creamos
un layout llamado swipe_images_layout que servirá de contenedor de
la colección de imágenes
<linearlayout android:layout_height="fill_parent" android:layout_width="fill_parent"
android:orientation="vertical"
<android .support.v4.view.viewpager="" android:id="@+id/swipe_pager"
android:layout_height="match_parent" android:layout_width="match_parent">
</android></linearlayout>
Por Ultimo mostrare el código en el que hacemos el llamado de nuestra galería.
<relativelayout android:layout_height="match_parent"
android:layout_width="match_parent"
android:paddingbottom="@dimen/activity_vertical_margin"
android:paddingleft="@dimen/activity_horizontal_margin"
android:paddingright="@dimen/activity_horizontal_margin"

android:paddingtop="@dimen/activity_vertical_margin"
tools:context=".MainActivity1"
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<button android:id="@+id/button" android:layout_centerhorizontal="true"
android:layout_centervertical="true" android:layout_height="wrap_content"
android:layout_width="wrap_content" android:text="Show image gallery">
</button></relativelayout>
Este proyecto en general solo nos sirve visualizar imágenes ya que a la hora de
seleccionamos la imagen podremos sencillamente visualizarla en su tamaño
original.
18
APLIACION 7: Calculadora.
Puesto que esta aplicación es algo más laboriosa me daré a la tarea de poder
enumerar paso a paso el proceso y la creación de la aplicación.
Como en todos los proyectos tenemos que poner nombre y demás.
En la elaboración de la interfaz grafica tendrás que elaborar botón por botón
haciendo énfasis a cada número y botón que se utilizara:
1° Abrir MainActivity.java y programar la lógica:
Se crean métodos para cada botón. (No olvidar importar las librerías necesarias)
}

getMenuInflater().inflate(R.menu.main, menu);
return true;
}
Double numero1,numero2,resultado;
String operador;
public void onClickIgual(View miView)
{
TextView tv = (TextView) findViewById(R.id.txtNumero) ;
numero2 = Double.parseDouble(tv.getText().toString());
if(operador.equals("+"))
{
19
resultado= numero1+numero2;
}
else if(operador.equals("-"))
{
resultado= numero1-numero2;
}
else if(operador.equals("*"))
{
resultado= numero1*numero2;
}
else if(operador.equals("/"))
{
resultado= numero1/numero2;
}
tv.setText(resultado.toString());
}
public void onClickSuma(View miView)
{
operador="+";
onClickOperacionCapturaNumero1(miView);
}
public void onClickResta(View miView)
{
operador="-";
}
public void onClickMultiplicacion(View miView)
{

operador="*";
}
public void onClickDivision(View miView)
{
operador="/";
}
public void onClickOperacionCapturaNumero1(View miView)
{
numero1 = Double.parseDouble(tv.getText().toString());
tv.setText("");
}
public void onClickLimpia(View miView)
{
20
numero1=0.0;
numero2=0.0;
tv.setText("");
}
public void onClickBtn1(View miView)
{
tv.setText(tv.getText() + "1");
}
{
}
public void onClickBtn3(View miView) {
}
}
}

{
}
{
}
{
}
21
}
{
}
public void onClickBtnPunto(View miView)
{
tv.setText(tv.getText() + ".");
}
}
En este código podemos observar que se definen las operaciones y la función
que tendrá cada botón colocado en tu interfaz grafica.
No olvidemos en el XML debemos declarar cada botón que utilizaremos.
Prácticamente esta seria toda la aplicación puesto lo fundamental es la parte
lógica del java en donde damos cada una de las instrucciones por hacer.

22
APLIACION 8: Acelerómetro.
En esta es una caso similar a la anterior puesto que no hay gran necesidad de
explicar cosa alguna puesto que solo tendremos que pedir permiso al sensor del
dispositivo móvil y agregar algunas librerías.
Este se compone de 3 ejes, X , Y y Z los cuales cada uno genera una entrada que se
mide en gravedad.
A continuación este código registra entradas del acelerómetro y lo muestra en
pantalla.
import android.content.pm.ActivityInfo;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
//Librerias agregadas
TextView x,y,z;

private Sensor mAccelerometer;
@Override
x = (TextView)findViewById(R.id.xID);
y = (TextView)findViewById(R.id.yID);
z = (TextView)findViewById(R.id.zID);
// Definimos nuestra variables utilizadas
this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}
protected void onResume()
{
super.onResume();
SensorManager sm = (SensorManager)
getSystemService(SENSOR_SERVICE);
23
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); }
}
protected void onPause()
{
SensorManager mSensorManager=(SensorManager)
mSensorManager.unregisterListener(this, mAccelerometer);
super.onPause(); }
protected void onStop() {
SensorManager mSensorManager=(SensorManager)
mSensorManager.unregisterListener(this, mAccelerometer);
super.onStop(); }
public void onSensorChanged(SensorEvent event) {
this.x.setText("X = "+event.values[SensorManager.DATA_X]);
this.y.setText("Y = "+event.values[SensorManager.DATA_Y]);
this.z.setText("Z = "+event.values[SensorManager.DATA_Z]);
}
// Aquí vemos lo que son los valores de entrada en el acelerómetro

@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
Las librerías que agregamos en el código son las siguientes en estas como ya
mocionaba se le pide permiso al sensor del dispositivo:
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager
Este Programa es más que nada pues coordenado y las podremos utilizar para
muchas actividades diferentes como tal no hay conclusión por dar.
24
APLIACION 9: Toggle Button.
Toggle Button es más que nada otro tipo de botón a los que ya le he presentado
anterior mente la diferencia entre estos solo es el diseño o el tipo de botón y el uso
que se puede dar a cada uno de estos.
En primer paso lo que haremos será definir nuestros botones:
<resources>
<string name="app_name">MyAndroidApp</string>
<string name="toggle_turn_on">Turn On</string>
<string name="toggle_turn_off">Turn Off</string>
<string name="btn_display">Display</string>
</resources>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<ToggleButton

android:id="@+id/toggleButton1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
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" />
</LinearLayout>
25
En el código observamos que se ponen los botones y definimos el tamaño de cada
uno de ellos este viene siendo el código XML.
En segundo lugar desarrollaremos nuestro código como ya sabemos en donde
elaboraremos la lógica del programa o el código JAVA.
import android.view.View.OnClickListener;
import android.widget.Toast;
import android.widget.ToggleButton;
public class MyAndroidAppActivity extends Activity {
private ToggleButton toggleButton1, toggleButton2;
private Button btnDisplay;
@Override

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() {
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();
}
26
En esta aplicación nos damos cuenta de los diferentes usos que les podemos dar
a los botones como este ya que tiene o pueden ser utilizados para varias cosas o
aplicaciones.

27
APLIACION 10: Sonidos.
Este código es fácil de elaborar puesto que lo único que tenemos que realizar
seria agregar los sonidos de reproducción en la carpeta RAW que se genera
cuando creamos el proyecto.
Después de eso tendremos que poner la cantidad de botones que se desean
utilizar esto porque los requeriremos ya que a la hora de dar le clic al botón sonara
el sonido ingresado y depende de la condición redactada.
A continuación el código:
import android.media.MediaPlayer;

}
@Override
return true;
}
public void presionGato(View v) {
MediaPlayer mp = MediaPlayer.create(this, R.raw.gato);
mp.start();
}
public void presionLeon(View v) {
28
MediaPlayer mp = MediaPlayer.create(this, R.raw.leon);
mp.start();
}
}
Este código es con el cual se mandan a llamar o relacionar los sonidos.
MediaPlayer mp=MediaPlayer.create(this,R.raw.gato);
Y seguida de ese mandaremos a llamar el método start.
mp.start();
Con este código podremos elaborar una tabla de sonidos o algo similar con la cual
se vuelva un juego didáctico

29
APLIACION 11: Giroscopio.
A continuación les daré los pasos a seguir para la elaboración del giroscopio
En primer lugar tendremos que agregar (android:id="@+id/salida”) a nuestro
TextViwe.
En nuestro activity main agregaremos algunos de los recursos solicitados para
utilizar el giroscopio.
public class SensoresActivity extends Activity {
private TextView salida;
@Override
salida = (TextView) findViewById(R.id.salida);
SensorManager sensorManager = (SensorManager)

List<Sensor> listaSensores = sensorManager.
getSensorList(Sensor.TYPE_ALL);
for(Sensor sensor: listaSensores) {
log(sensor.getName());
}
}
private void log(String string) {
salida.append(string + "n");
}
}
30
Para después poder agregar el código a final del método Oncreate el siguiente
código
listaSensores = sensorManager.getSensorList(Sensor.TYPE_ORIENTATION);
if (!listaSensores.isEmpty()) {
Sensor orientationSensor = listaSensores.get(0);
sensorManager.registerListener(this, orientationSensor,
SensorManager.SENSOR_DELAY_UI)
;}
listaSensores = sensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER);
Sensor acelerometerSensor = listaSensores.get(0);
sensorManager.registerListener(this, acelerometerSensor,
;}
listaSensores = sensorManager.getSensorList(Sensor.TYPE_MAGNETIC_FIELD);
Sensor magneticSensor = listaSensores.get(0);
sensorManager.registerListener(this, magneticSensor,
;}
listaSensores = sensorManager.getSensorList(Sensor.TYPE_TEMPERATURE);

Sensor temperatureSensor = listaSensores.get(0);
sensorManager.registerListener(this, temperatureSensor,
SensorManager.SENSOR_DE
aquí se muestran una series de condiciones que nos ayudaran a realizar las
ordenes solicitadas por el dispositivo .
Para poder finalizar nuestro proyecto tenemos que solicitar o recibir los valores o
los datos de los sensores con el siguiente código.
public void onSensorChanged(SensorEvent evento) {
//Cada sensor puede provocar que un thread principal pase por aquí
//así que sincronizamos el acceso (se verá más adelante)
synchronized (this) {
switch(evento.sensor.getType()) {
case Sensor.TYPE_ORIENTATION:
for (int i=0 ; i<3 ; i++) {
log("Orientación "+i+": "+evento.values[i]);
}
31
break;
case Sensor.TYPE_ACCELEROMETER:
for (int i=0 ; i<3 ; i++) {
log("Acelerómetro "+i+": "+evento.values[i]);
}
break;
case Sensor.TYPE_MAGNETIC_FIELD:
for (int i=0 ; i<3 ; i++) {
log("Magnetismo "+i+": "+evento.values[i]);
}
break;
default:
for (int i=0 ; i<evento.values.length ; i++) {
log("Temperatura "+i+": "+evento.values[i]);
}
}
}
}
Y pues este es todo el código que necesitamos tanto para las condiciones como
para recibir los datos solicitados con esta aplicación podremos realizar varios

ejercicios o simplemente la podremos utilizara como lo dice el nombre de la
aplicación para un giroscopio.
32
APLIACION 12: ProgessBar.
Este es como si pusiéramos una imagen dentro de nuestro dispositivo móvil como
si fuera un icono común para eso tendremos que pedir una serie de permisos.
A continuación mostrare el código para la interfaz grafica y las librerías que
tendremos que agregar:
import android.os.AsyncTask;
import android.os.SystemClock;
<ProgressBar
android:id="@+id/progressbar"
style="?android:attr/progressBarStyleHorizontal"

android:max="100"
android:progress="50"
/>
A continuación mostrare lo que es el código de JAVA:
buttonStart = (Button)findViewById(R.id.start);
progressBar = (ProgressBar)findViewById(R.id.progressbar);
buttonStart.setOnClickListener(new Button.OnClickListener(){
public void onClick(View arg0) {
// TODO Auto-generated method stub
buttonStart.setClickable(false);
new asyncTaskUpdateProgress().execute();
}
});
}
33
public class asyncTaskUpdateProgress extends AsyncTask<Void, Integer, Void> {
int progress;
protected void onPostExecute(Void result) {
buttonStart.setClickable(true);
}
protected void onPreExecute() {
progress = 0;
}
protected void onProgressUpdate(Integer... values) {
progressBar.setProgress(values[0]);

}
protected Void doInBackground(Void... arg0) {
while(progress<100){
progress++;
publishProgress(progress);
SystemClock.sleep(100);
}
return null;
}
}
Por último podrás correr el programa mediante tu emulador y veras la imagen que
tú pusiste en el inicio de tu pantalla más que nada es como un simple icono dentro
de tu dispositivo.
34
APLIACION 13: Spinner.
El Spinner es una herramienta más que podremos utilizar en diversas actividades
como en las más sencillas una calculadora la cual les presentare el código. El
control Spinner muestra una lista de String y nos permite seleccionar uno de ellos
cuando se lo selecciona se abre y muestra todos sus elementos para permitir
seleccionar uno de ellos.
A continuación les presentare el código XML o grafico:
android:layout_height="match_parent"
tools:context=".MainActivity" >
<TextView
android:id="@+id/textView1"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true"
android:text="Ingrese primer valor:" />

<EditText
android:id="@+id/et1"
android:layout_below="@+id/textView1"
android:ems="10"/>
<TextView
android:id="@+id/textView2"
android:layout_below="@+id/et1"
android:text="Ingrese segundo valor:"/>
<EditText
android:id="@+id/et2"
android:layout_below="@+id/textView2"
android:ems="10">
<requestFocus />
</EditText> 35
<Spinner
android:id="@+id/spinner1"
android:layout_below="@+id/et2"/>
<Button
android:id="@+id/button1"
android:layout_below="@+id/spinner1"
android:onClick="operar"
android:text="operar"/>
<TextView
android:id="@+id/tv3"

android:layout_below="@+id/button1"
android:text="resultado"/>
Aquí observamos lo que viene siendo la parte que se le muestra al usuario ósea la
interfaz grafica como ya lo hemos observado en los programas anteriores ahora
pasaremos a la parte lógica ósea el desarrollo como tal.
importandroid.app.Activity;
importandroid.os.Bundle;
importandroid.view.Menu;
importandroid.view.View;
importandroid.widget.ArrayAdapter;
importandroid.widget.EditText;
importandroid.widget.Spinner;
librerias agregada para el desarrollo
importandroid.widget.TextView;
private Spinner spinner1;
36
spinner1 = (Spinner) findViewById(R.id.spinner1);
String []opciones={"sumar","restar","multiplicar","dividir"};
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_spinner_item,
opciones);
spinner1.setAdapter(adapter); }
getMenuInflater().inflate(R.menu.activity_main,menu);
return true;
}

String selec=spinner1.getSelectedItem().toString();
if (selec.equals("sumar")) {
int suma=nro1+nro2;
tv3.setText(resu);
} else
if (selec.equals("restar")) {
tv3.setText(resu);
}
else if (selec.equals("multiplicar")) {
int multi=nro1*nro2;
String resu=String.valueOf(multi);
tv3.setText(resu);
} Else
if (selec.equals("dividir")) {
int divi=nro1/nro2;
String resu=String.valueOf(divi);
tv3.setText(resu);
37
Cuando el programa es corrido mediante el emulador nos damos cuenta que al
presionar el botón se extraen todo el contenido del Spinner .
Todo los if utilizados en dicho programa nos ayudan a verificar la acción que se
hará o realizara dependiendo lo pedido.

38
APLIACION 14: ListView.
El ListView es sencillo puesto que solo lo utilizaremos cuando se puedan
seleccionar sin necesidad de dar clic o cerrar el ciclo o avance del programa.
Lo primero que se mostrara será la parte Lógica de nuestro proyecto:
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.ListView;
private String[] paises = { "Argentina","Chile","Paraguay","Bolivia",
"Peru","Ecuador","Brasil","Colombia","Venezuela","Uruguay" };

private String[] habitantes = {"40000000","17000000","6500000",
"10000000", "30000000","14000000","183000000","44000000",
"29000000","3500000" };
private ListView lv1;
@Override
lv1 =(ListView)findViewById(R.id.listView1);
ArrayAdapter <String> adapter = new
ArrayAdapter<String>(this,android.R.layout.simple_list_item_1, paises);
lv1.setAdapter(adapter);
lv1.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View v, int posicion, long id) {
tv1.setText("Población de "+ lv1.getItemAtPosition(posicion) + " es "+ habitantes[posicion]);
}
}); }
return true;
}} 39
Primero definimos dos vectores paralelos donde almacenamos en uno los
nombres de países y en el otro almacenamos la cantidad de habitantes de dichos
países. Definimos un objeto de tipo TextView y otro de tipo ListView donde
almacenaremos las referencias a los objetos que definimos en el archivo XML.
A continuación mostrare el código XML:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
<TextView
android:id="@+id/tv1"
android:layout_alignParentTop="true"

android:text="TextView" />
<ListView
android:id="@+id/listView1"
android:layout_below="@+id/tv1" >
</ListView>
</RelativeLayout>
La conclusión de dicho programa es que lo podemos utilizar para diversas
actividades y más que nada cuando se tratan de elegir y mostrar resultado o cual
quiera tipo de dato mediante un textViwe.
40
APLIACION 15: Piano.
Este programa consiste en el mismo código que el de SONIDOS ya visto atrás
para este no pondré el código puesto que puede utilizar el anterior y es muy fácil
puesto que en vez de utilizar el botón puedes utilizar o debes utilizar un
ImageViwe las imágenes como ya mencione también van colocadas en la carpeta
MDPI .
Lo único de diferente es que a la hora de que tu presionabas el botón ahora
tendrás que apretar una imagen la que de acuerdo con tu JAVA te dará
indicaciones para genere el sonido indicado para cada una de las imágenes ósea
teclas esto mismo lo puedes realizar con los SONIDOS de animales

41
APLIACION 16: WebView.
En esta aplicación solo será fácil de realizar pero antes que todo tenemos que
tener realizada alguna pagina web de la manera que ustedes gusten tal vez
HTML.
Después de tener ya echa nuestra página web debemos incluir a nuestro layout lo
siguiente:
<?xml version="1.0" encoding="utf-8"?>
<WebView xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="fill_parent"
android:id="@+id/webview" />

Posteriormente desde el código de nuestra activity cambiaremos las settings del WebView si
procede e indicaremos la url a cargar en el mismo:
private WebView mWebView;
mWebView = (WebView) findViewById(R.id.webview);
// Activo JavaScript
mWebView.getSettings().setJavaScriptEnabled(true);
// Cargamos la url que necesitamos
mWebView.loadUrl("http://www.ingens-networks.com/blog/");
}
Para esto necesitamos un permiso el cual se muestra adelante:
<uses-permission android:name=“android.permission.INTERNET” />
Y esto es todo lo de esta aplicación simplemente es la elaboración de una caja de
texto en donde pondrás tu URL y un botón con el cual buscara y te llevara ala
pagina deseada.
42
APLIACION 17: VideoView.
En esta Aplicación o Proyecto se utilizara un código con distintas cosas puesto
que mediante ese código podremos bajar un video y reproducirlo
automáticamente.

<LinearLayout
xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical”
android:layout_width=”match_parent”
android:layout_height=”match_parent”>
<VideoView
android:id=”@+id/surface_view”
android:layout_width=”320px”
android:layout_height=”240px”/>
</LinearLayout>
Ok el código anterior nos sirve para poder establecer las medidas adecuadas de
nuestro video que tendremos que bajar.
El código siguiente es el que tendremos que insertar en nuestro JAVA ósea la
parte lógica del programa:
public class videoView extends Activity {
private VideoView mVideoView;
@Override public void onCreate(Bundle savedInstanceState){
mVideoView =(VideoView)findViewById(R.id.surface_view);
//de forma alternativa si queremos un streaming usar
//mVideoView.setVideoURI(Uri.parse(URLstring));
mVideoView.setVideoPath(“/mnt/sdcard/video.mp4”);
43
mVideoView.start();
mVideoView.requestFocus();
}}
Es necesario almacenar un fichero de video en el simulador. Para ello, utiliza la
opción del menúWindow > Show View >Others… > Android > File Explorer. Te
mostrará el sistema de ficheros del emulador.
Selecciona la carpeta mnt/sdcard y utiliza el botón donde aparece un teléfono con
una flecha para almacenar un nuevo fichero. Indica el fichero video.mp4.
Con esto podremos obtener un reproductor de video simplemente remplazando de
manera adecuada todo el código dado anteriormente.

APLIACION 18: TabHost.
Tabhost esta aplicación trata de el desarrollo de diferentes pestañas atreves de la
mis interfaz que quieres decir esto que no tendrás que desarrollar algún otro XML.
44
A continuación les mostrare el código XML con el que acomodaremos nuestras
pestañas:
<TabHost
android:id=”@android:id/tabhost”
android:layout_height=”match_parent”
android:layout_alignParentLeft=”true”
android:layout_alignParentTop=”true” >
<LinearLayout
android:layout_height=”match_parent”
android:orientation=”vertical” >
<
android:id=”@android:id/tabs”
android:layout_height=”wrap_content” >
</TabWidget>
<FrameLayout

android:id=”@android:id/tabcontent”
android:layout_height=”match_parent” >
<LinearLayout
android:id=”@+id/tab1”
android:layout_height=”match_parent” >
</LinearLayout>
<LinearLayout
android:id="@+id/tab2"
android:layout_height="match_parent" >
</LinearLayout>
<LinearLayout
android:id="@+id/tab3"
</LinearLayout>
</FrameLayout>
</LinearLayout>
</TabHost>
45
Ahora bien ese el código que tendríamos que utilizar para el programa en la parte
GRAFICA en la parte JAVA mostrare las indicaciones que debe de realizar cada
pestaña:
pestaña=contenedorPestaña.newTabSpec("pestana1");
pestaña.setContent(R.id.tab1);
pestaña.setIndicator("Pestaña 1",
getResources().getDrawable(android.R.drawable.ic_menu_help));
contenedorPestaña.addTab(pestaña);
getResources().getDrawable(android.R.drawable.ic_btn_speak_now));
getResources().getDrawable(android.R.drawable.ic_menu_agenda));
Aquí mismo mandamos a llamar desde en XML cada una de nuestras pestañas
para que posteriormente genere las acciones.
Para activar y mandar a llamar una pestaña tenemos que agregar al
método setCurrentTab() pasándole un número que corresponde a cada pestaña.

La conclusión de dicho programa es que con este podemos hacer una lista de
reproducción en donde tengamos dos pestañas mínimo una de canciones y otra
de favoritas o podemos hacer cualquier otra aplicación siempre y cuando tengas
que requerir el uso de 2 tabhost.
contenedorPestana=(TabHost)
findViewById(android.R.id.tabhost);
contenedorPestana.setup()
pestana=contenedorPestana.newTabSpec("pestana1");
pestana.setContent(R.id.tab1);
pestana.setIndicator("Pestana 1",
getResources().getDrawable(android.R.drawable.ic_menu_help));
contenedorPestana.addTab(pestana);
contenedorPestana.setOnTabChangedListener(new OnTabChangeListener() {
@Override
public void onTabChanged(String nombrePestana) {
//aqui implementariamos el código
Log.i("RONALDO","Has pulsado :" + nombrePestana);
46
APLIACION 19: Widget.
El widget es una aplicación independiente puesto que solo la podemos utilizar con
un botón y un par de condiciones sin necesidad de mater IF tras IF.
Para esta Aplicación necesitaremos dos imágenes las cuales nos servirán para la
elaboración del programa.Depues de esto como ya mencionado en programas
anteriores las imágenes las pondremos en nuestra carpeta llamada MDPI.
A continuación el código XML.
<ImageButton xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/ibFlashlight"
android:layout_width="60dp"
android:layout_height="60dp"
android:scaleType="fitCenter"
android:background="@drawable/bombilla_off" >
</ImageButton>

Aquí se muestra las indicaciones que debemos tener con nuestra imagen.
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
android:initialLayout="@layout/flashlight_layout"
android:minHeight="60dp"
android:minWidth="60dp">
</appwidget-provider>
Ahora en esta otra parte del XML se muestra las condiciones de nuestro WIDGET
el cual debe de coincidir con nuestra imagen
public class FlashlightWidgetProvider extends AppWidgetProvider
{
public static final String PUSH_ACTION =
"org.danigarcia.android.flashlight.FlashlightWidgetProvider.PUSH_ACTION";
}
47
Pasaremos a la parte Lógica a Nuestro JAVA.
Este código es el que nos ayudara a identificar la acción para cada WIDGET.
Pero eso no es todo para que nos pueda detectar los demás acciones debemos agregar
el siguiente código:
public static PendingIntent generarIntentBroadcast(Context context)
{
// Creamos un nuevo Intent y le asociamos la accion PUSH_ACTION para que el
BroadcastReceiver
// pueda distinguir su tipo
Intent intent = new Intent();
intent.setAction(PUSH_ACTION);
// Generamos el intent y lo devolvemos como resultado del método.
return PendingIntent.getBroadcast(context, 0, intent,
PendingIntent.FLAG_UPDATE_CURRENT);
}
En segundo lugar para que se vuelvan nulos los datos del WIDGET tendremos
que utilizar otro código que mostrare ahora:

public static void solicitarUpdate(Context context, RemoteViews views)
{
// Creamos un ComponentName a partir del paquete y la clase
ComponentName widget = new ComponentName(context,
FlashlightWidgetProvider.class);
// Obtenemos una referencia al AppWidgetManager
AppWidgetManager awManager = AppWidgetManager.getInstance(context);
// Solicitamos una actualizacion al AppWidget
awManager.updateAppWidget(widget, views);
}
Cada vez que utilicemos nuestra aplicación se borraran los datos de manera que se
generaran diferentes acciones según lo solicitado.
Con este código nuestra aplicación ya es capaz de funcionar como WIDGET atreves de
dos imágenes las cuales solo seguirán indicaciones y funcionaran como botones.
48
APLIACION 20: Notificaciones.
Bien en esta aplicación desarrollaremos lo que una notificación para cual quiera que
necesite combinar alguna otra aplicación le será de mucha ayuda el siguiente código.
A continuación mostrare lo que el código XML de nuestra notificación:
<LinearLayout
android:orientation="vertical"
tools:context=".Noti" >
<Button
android:id="@+id/Notificacion"
android:onClick="onClick"
android:text="Notificaciones" />

</LinearLayout>
Como ya sabemos el button será la acción que nos mostrara nuestra notificación el
momento requerido aquí mostramos también las medidas que debe tener dicho botón
como también lo declaramos.
En nuestro método JAVA como lo hemos repetido infinidad de veces mostraremos el
funcionamiento como tal:
setContentView(R.layout.activity_noti);
}
public void onClick(View v){
displayNotification();
}
protected void displayNotification(){
Intent i = new Intent(this, NotificationView.class);
i.putExtra("notificationID", notificationID);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, i, 0);
NotificationManager nm =
(NotificationManager)getSystemService(NOTIFICATION_SERVICE);
49
CharSequence ticker ="Nueva entrada en SekthDroid";
CharSequence contentTitle = "SekthDroid";
CharSequence contentText = "Visita ahora SekthDroid!";
notici noti = new NotificationCompat.Builder(this)
.setContentIntent(pendingIntent)
.setTicker(ticker)
.setContentTitle(contentTitle)
.setContentText(contentText)
.setSmallIcon(R.drawable.ic_launcher)
.addAction(R.drawable.ic_launcher, ticker, pendingIntent)
.setVibrate(new long[] {100, 250, 100, 500})
.build();
nm.notify(noticiID, noti);
}
}
En todos nuestros set contents establecemos parámetros para el funcionamiento
adecuado obvio cada uno tiene diferente acción:
SMALLCON que sirve para mostrar algo dependiendo de nuestra notificación.

VIBRATE como su nombre lo dice este nos ayudara a que después de nuestro
dispositivo reciba la notificación recibirá una notificación.
50
APLIACION 21: Calcular Edad.
Esta aplicación constan de diferentes condiciones las cuales nos ayudaran a saber
la edad atreves de una serie de datos .
A continuación el código JAVA:
public int edad(String fecha_nac) { //fecha_nac debe tener el formato dd/MM/yyyy
Date fechaActual = new Date();
SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
String hoy = formato.format(fechaActual);
String[] dat1 = fecha_nac.split("/");
String[] dat2 = hoy.split("/");
int anos = Integer.parseInt(dat2[2]) - Integer.parseInt(dat1[2]);
int mes = Integer.parseInt(dat2[1]) - Integer.parseInt(dat1[1]);
if (mes < 0) {
anos = anos - 1;
} else if (mes == 0) {
int dia = Integer.parseInt(dat2[0]) - Integer.parseInt(dat1[0]);
if (dia > 0) {
anos = anos - 1;
}
}

return anos;
Aquí podemos observar que para empezar debemos de declarar todas nuestras variables
que utilizaremos para después utilizar una serie de if con los cuales podremos calcular la
edad exacta de la persona.
51
Por último en nuestro código XML solo utilizaresmos tres TEXTVIWE y un BOTONlos tres
text son en donde el usuario colocara sus tres datos solicitados y en botón será el que
genere la acción para que después le muestre el resultado.
Esta aplicación es útil ya que sin complicarnos tanto podremos saber la edad de alguna
persona sin necesidad de quebrarnos la cabeza pensando.
APLIACION 22: Cámara.
Esta aplicación consta de poder utilizar la cámara del dispositivo para tomar fotos
directamente desde nuestra aplicación
CODIGO JAVA:

private static int TAKE_PICTURE = 1;
private static int SELECT_PICTURE = 2;
private String name = "";
name = Environment.getExternalStorageDirectory() + "/test.jpg";
Button btnAction = (Button)findViewById(R.id.btnPic);
btnAction.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
...
}
}
}
RadioButton rbtnFull = (RadioButton)findViewById(R.id.radbtnFull);
RadioButton rbtnGallery = (RadioButton)findViewById(R.id.radbtnGall);
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
if (rbtnFull.isChecked()) {
Uri output = Uri.fromFile(new File(name));
intent.putExtra(MediaStore.EXTRA_OUTPUT, output);
} else if (rbtnGallery.isChecked()){
intent = new Intent(Intent.ACTION_PICK,
android.provider.MediaStore.Images.Media.INTERNAL_CONTENT_URI);
code = SELECT_PICTURE;
}
52
Como podemos ver nuestro código XML contara de un RadioGroup y un botón
con el cual podremos mostrar.
aprendimos cómo pueden acomodarse componentes ubicándolos en el diseño con
posiciones relativas con respecto a otros componentes y también los controles
necesarios para el manejo de radio buttons y su agrupación.

53
APLIACION 23: Base de Datos.
En esta ocasión implementaremos o más bien usaremos la clase SQLiteOpenHelper que
nos facilita tanto la creación de la base de datos posteriormente también utilizaremos los
métodos como el ya conocido onCreate(), y onUpgrade().
A continuación una vez que ya hayas creado tu clase y tu proyecto tendrás que insertar el
siguiente código perteneciente al JAVA.
public class AlmacenPuntuacionesSQLite extends SQLiteOpenHelper implements
AlmacenPuntuaciones{
Métodos de SQLiteOpenHelper para elaborar la BD
public AlmacenPuntuacionesSQLite(Context context) {
super(context, "puntuaciones", null, 1);
}
@Override public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE puntuaciones ("+
"_id INTEGER PRIMARY KEY AUTOINCREMENT, "+
"puntos INTEGER, nombre TEXT, fecha LONG)");
}
@Override public void onUpgrade(SQLiteDatabase db, intoldVersion, int
newVersion) {

En caso de una nueva versión habría que actualizar las tablas para evitar errores
}
Métodos de AlmacenPuntuaciones
public void guardarPuntuacion(int puntos, String nombre, long fecha) {
SQLiteDatabase db = getWritableDatabase();
db.execSQL("INSERT INTO puntuaciones VALUES ( null, "+
puntos+", '"+nombre+"', "+fecha+")");
db.close();
}
public Vector listaPuntuaciones(int cantidad) {
Vector result = new Vector();
SQLiteDatabase db = getReadableDatabase();
Cursor cursor = db.rawQuery("SELECT puntos, nombre FROM " +
"puntuaciones ORDER BYpuntos DESC LIMIT " +cantidad, null);
while (cursor.moveToNext()){
result.add(cursor.getInt(0)+" " +cursor.getString(1));
}
cursor.close();
db.close();
return result;
}
}
54
Los únicos parámetros que utilizaremos contexto, nombre, curso y versión.
En esta base de datos en la creación de esta BD es necesario mandar a llamar el
método que ya aviamos dicho que utilizaremos ósea el que viene siendo onCreate().
En el código anterior tenemos todo lo necesario para que nuestra aplicación genere una
BD y guarde los registros solicitados.
APLIACION 25: Eliminar BD.

Bueno para esta práctica es más fácil y no requerimos prácticamente de ningún código ni
de JAVA ni de XML.
Lo primero que haremos será dentro del ECLIPSE ósea donde desarrollaste tu APP
tendremos que entrar al FLIE EXPLORER ahí tienes que buscar la ruta o más bien
tendras que buscar tu base de datos como lo mostramos adelante.
55
Después de estar ahí tendrás que buscar entre toda la lista de tus otras app’s creadas
deberás buscar la que requieres esto para que dentro del fichero encuentres le archivo
llamado DATA BASE directamente desde ahí podrás eliminar todos los datos que
contenga dicha base o haya almacenado.
APLIACION 25: Canvas.

Bien en esta app aprenderemos como realizar la aplicación de canvas aquí
podremos dibujar figuras esto mediante los datos ingresados.
Bien ahora pasaremos a la creación y explicación del código JAVA.
public class CanvasView extends View {
Tamaño de la pantalla que va a tener por defecto.
private static final float DWIDTH = 480, DHEIGHT = 800;
private Resources resources;
private Paint paintObject, paintPath;
private Bitmap bmpIcon;
private RectF rect01;
private Path path01;
/**
public CanvasView(Context context, AttributeSet attrs) {
super(context, attrs);
resources = context.getResources();
_init();
}
/**
Decalramos los valores para ser pintados en el Canvas
private void _init() {
paintObject = new Paint();
paintObject.setARGB(255, 255, 0, 0);
56
bmpIcon = BitmapFactory.decodeResource(resources)
R.drawable.ic_launcher);
rect01 = new RectF(250, 500, 350, 600);
path01 = new Path();
path01.moveTo(50, 400);
path01.lineTo(225, 650);
paintPath = new Paint();
paintPath.setColor(0xFF00FF00);
paintPath.setStyle(Paint.Style.STROKE);
paintPath.setStrokeWidth(3);
}
@Override
public void onDraw(Canvas canvas) {
super.onDraw(canvas);
Este código sirve para escalar la pantalla y dibujar en la pantalla.
canvas.save();
canvas.scale(canvas.getWidth() / DWIDTH, canvas.getHeight() / DHEIGHT);
canvas.drawColor(0xFF000000);
canvas.drawCircle(100, 100, 50, paintObject);
if (bmpIcon != null) {
canvas.drawBitmap(bmpIcon, 200, 200, null);
}
canvas.drawRect(rect01, paintObject);
canvas.drawPath(path01, paintPath);

canvas.restore();
}
}
Este es el código del Manifest:
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@android:style/Theme.Black.NoTitleBar.Fullscreen" >
<activity
android:name="com.carlospinan.canvasandroidpost.MainActivity"
android:label="@string/app_name"
android:screenOrientation="portrait" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Este es el código del Layout:
<com.carlospinan.canvasandroidpost.CanvasView
57
android:id="@+id/canvasView
</com.carlospinan.canvasandroidpost.CanvasView>
</FrameLayout>
Cabe mencionar que en esta práctica lo único que utilizaremos en el formulario XML será
la creación y dimensiones de la pantalla en donde se dibujaran las figuras
Esta sería la pantalla con nuestra figura dibujada:

Por último cabe mencionar que todos los código en ECLIPSE tendrá que ponerse de
colores aquí no porque todos los d este manual tiene un formato para cuidar más que
nada la presentación para el lector.
58

Manual de aplicaciones moviles

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (13)

Similar a Manual de aplicaciones moviles

Similar a Manual de aplicaciones moviles (20)

Manual de aplicaciones moviles